package com.yanqu.road.server.manger.log;

import com.alibaba.fastjson.JSON;
import com.yanqu.road.entity.activity.twins.log.LogTwinsDrawKungFu;
import com.yanqu.road.entity.activity.twins.log.LogTwinsKungFuCombUnlock;
import com.yanqu.road.entity.activity.twins.log.LogTwinsKungFuUpgrade;
import com.yanqu.road.entity.activity.twins.log.LogTwinsPveBattle;
import com.yanqu.road.entity.config.goods.MallInfo;
import com.yanqu.road.entity.enums.eLogMoneyType;
import com.yanqu.road.entity.log.*;
import com.yanqu.road.entity.log.vehiclesoul.*;
import com.yanqu.road.entity.monopolymarket.office.log.MonopolyMarketFortressDispatchLogData;
import com.yanqu.road.entity.monopolymarket.office.log.MonopolyMarketOfficeUserSeatLogData;
import com.yanqu.road.entity.monopolymarket.office.log.MonopolyMarketUserPhysicalChangeLogData;
import com.yanqu.road.logic.bussiness.log.LogBussiness;
import com.yanqu.road.logic.bussiness.servercenter.PlatformUserIdInfoBussiness;
import com.yanqu.road.logic.config.ChannelConfig;
import com.yanqu.road.logic.config.GameConfig;
import com.yanqu.road.server.TempMgr;
import com.yanqu.road.server.gameplayer.GamePlayer;
import com.yanqu.road.server.manger.config.MallRechargeConfigMgr;
import com.yanqu.road.server.manger.maidian.DefaultEventTraceAction;
import com.yanqu.road.utils.ConfigHelper;
import com.yanqu.road.utils.TimeHelper;
import com.yanqu.road.utils.http.HttpHelper;
import com.yanqu.road.utils.kafka.EmptyProducer;
import com.yanqu.road.utils.kafka.KafKaHelper;
import com.yanqu.road.utils.order.OrderHelper;
import com.yanqu.road.utils.string.StringUtils;
import org.apache.commons.collections.CollectionUtils;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * log保存类
 */
public class LogMgr {
    private static List<LogDayLogin> logDayLoginList;
    private static List<LogOnlineNum> logOnlineNumList;
    private static List<LogRecharge> logRechargeList;
    private static List<LogIngots> logIngotsList;
    private static List<LogGoods> logGoodsList;
    private static List<LogPublishWanted> logPublishWantedList;
    private static List<LogTaskActiveReward> logTaskActiveRewardList;
    private static List<LogTaskReward> logTaskRewardList;
    private static List<LogBeautyUpgrade> logBeautyUpgradeList;

    private static List<LogEstateFloorRiseReward> logEstateFloorRiseRewardList;
    private static List<LogUnionBuilding> logUnionBuildingList;
    private static List<LogMineWarReward> logMineWarRewardList;
    private static List<LogOreWarReward> logOreWarRewardList;
    private static List<LogSacrificeKill> logSacrificeKillList;
    private static List<LogSacrificeDamageRankReward> logSacrificeDamageRankRewardList;
    private static List<LogCommonActivityScore> logCommonActivityScoreList;
    private static List<LogCommonActivityUseGoods> logCommonActivityUseGoodsList;
    private static List<LogTrystActivityUseGoods> logTrystActivityUseGoodsList;
    private static List<LogCommonActivityRankReward> logCommonActivityRankRewardList;
    private static List<LogOreWarActivityRankReward> logOreWarActivityRankRewardList;
    private static List<LogSacrificeAttack> logSacrificeAttackList;
    private static List<LogUseAddAttributeGoods> logUseAddAttributeGoodsList;
    private static List<LogMammonWorship> logMammonWorshipList;
    private static List<LogMammonCongratulate> logMammonCongratulateList;
    private static List<LogWorship> logWorshipList;
    private static List<LogEstateWorship> logEstateWorshipList;
    private static List<LogEstateWine> logEstateWineList;
    private static List<LogCommonActivityGoodsAutoConsume> logCommonActivityGoodsAutoConsumeList;
    private static List<LogTitleUpgradeBag> logTitleUpgradeBagList;
    private static List<LogTitleUpgradeBeauty> logTitleUpgradeBeautyList;
    private static List<LogTitleUpgradeBuilding> logTitleUpgradeBuildingList;
    private static List<LogTitleUpgradeChild> logTitleUpgradeChildList;
    private static List<LogTitleUpgradePatrons> logTitleUpgradePatronsList;
    private static List<LogTitleUpgradeVehicle> logTitleUpgradeVehicleList;
    private static List<LogTitleUpgradeTravel> logTitleUpgradeTravelList;
    private static List<LogTitleUpgradeTradeWar> logTitleUpgradeTradeWarList;
    private static List<LogTitleUpgradeRelatives> logTitleUpgradeRelativesList;
    private static List<LogUnionParergon> logUnionParergonList;
    private static List<LogGetPassTransport> logGetPassTransportList;
    private static List<LogSecretVolumeIntegral> logSecretVolumeIntegrals;
    private static List<LogEarnSpeedFund> logEarnSpeedFundList;
    private static List<LogActivityDisperseGold> LogActivityDisperseGoldList;
    private static List<LogActivityDispGoldClientResult> logActivityDispGoldClientResultList;
    private static List<LogChildAddEarnSpeed> logChildAddEarnSpeedList;
    private static List<LogWishPoolValue> logWishPoolValueList;
    private static List<LogThirdRechargeDouble> logThirdRechargeDoubleList;
    private static List<String> logPlatFormUserLoginTimeList;
    private static List<LogVarietyDispatch> logVarietyDispatchList;
    private static List<LogVarietyRank> logVarietyRankList;
    private static List<LogBaiYeGet> logBaiYeGetList;
    private static List<LogBusyFarmingHarvest> logBusyFarmingHarvestList;
    private static List<LogBusyFarmingWatering> logBusyFarmingWateringList;
    private static List<LogBusyFarmingLandBuy> logBusyFarmingLandBuyList;
    private static List<LogBusyFarmingPlant> logBusyFarmingPlantList;
    private static List<LogBusyFarmingQuicken> logBusyFarmingQuickenList;
    private static List<LogBusyFarmingRemove> logBusyFarmingRemoveList;
    private static List<LogBusyFarmingSteal> logBusyFarmingStealList;

    //永安当
    private static List<LogPawnshopUpgrade> logPawnshopUpgradeList;
    private static List<LogPawnshopPolitics> logPawnshopPoliticsList;
    private static List<LogPawnshopRepair> logPawnshopRepairList;
    private static List<LogPawnshopFake> logPawnshopFakeList;
    private static List<LogPawnshopCoin> logPawnshopCoinList;
    private static List<LogPawnshopItem> logPawnshopItemList;
    private static List<LogSkinVolumeEmbroideryFix> logSkinVolumeEmbroideryFixList;
    private static List<LogSkinVolumePiecesGet> logSkinVolumePiecesGetList;
    private static List<LogThiefReward> logThiefRewardList;
    private static List<LogUnionChamberDispatch> logUnionChamberDispatchList;


    private static List<LogManorHarvest> logManorHarvestList;
    private static List<LogManorSpecialSkillLvUp> logManorSpecialSkillLvUpList;
    private static List<LogManorSkinLvUp> logManorSkinLvUpList;
    private static List<LogManorGuestUnLock> logManorGuestUnLockList;
    private static List<LogManorTechnologySkillLvUp> logManorTechnologySkillLvUpList;
    private static List<LogManorProsperousValueGet> logManorProsperousValueGetList;
    private static List<LogManorOutPutLvUp> logManorOutPutLvUpList;
    private static List<LogXiaYueSearch> logXiaYueSearchList;

    // 周年庆
    private static List<LogCelebrationProcess> logCelebrationProcessList;
    private static List<LogCelebrationFestiveChange> logCelebrationFestiveChangeList;

    //兰若寺
    private static List<LogLanRuoSiEliminate1> logLanRuoSiEliminate1List;
    private static List<LogLanRuoSiEliminate2> logLanRuoSiEliminate2List;
    private static List<LogLanRuoSiEnergy> logLanRuoSiEnergyList;

    // 灵狐聚宝、鬼吹灯
    private static List<LogTreasureFind> logTreasureFindList;

    //葫芦镇妖



    private static List<LogGourdChildMopUp> logGourdChildMopUpList;
    private static List<LogGourdChildDraw> logGourdChildDrawList;

    //葫芦山
    private static List<LogGourdPlantWatering> logGourdPlantWateringList;

    // 榷场
    private static List<MonopolyMarketUserPhysicalChangeLogData> logMonopolyMarketUserPhysicalChangeLogDataList;
    private static List<MonopolyMarketFortressDispatchLogData> logMonopolyMarketFortressDispatchLogDataList;
    private static List<MonopolyMarketOfficeUserSeatLogData> logMonopolyMarketOfficeUserSeatLogDataList;

    //冬季恋歌
    private static List<LogWinterLoveDig> logWinterLoveDigList;
    private static List<LogWinterLovePickUpItem> logWinterLovePickUpItemList;
    private static List<LogWinterLoveConvertReward> logWinterLoveConvertRewardList;

    //地府断案
    private static List<LogHellNpc> logHellNpcList;

    private static List<LogManorWeather> logManorWeatherList;
    // 百福宴
    private static List<LogGoodBanquetRecord> logGoodBanquetRecordList;


    // 水浒叶子牌
    private static List<LogShuiHuYeZiCardBattlerResultRecord> logShuiHuYeZiCardBattlerResultRecordList;
    private static List<LogShuiHuYeZiCardGetCard> logShuiHuYeZiCardGetCardList;
    private static List<LogShuiHuYeZiCardPVEBattlerRoundRecord> logShuiHuYeZiCardPVEBattlerRoundRecordList;


    private static List<LogToyHouseOrder> logToyHouseOrderList;
    private static List<LogToyHouseEliminate> logToyHouseEliminateList;
    private static List<LogToyHouseCandy> logToyHouseCandyList;



    // 蜀山
    private static List<LogShuShanBuildUp> logShuShanBuildUpList;
    private static List<LogShuShanGetDisciple> logShuShanGetDiscipleList;
    private static List<LogShuShanKickOutDisciple> logShuShanKickOutDiscipleList;
    private static List<LogShuShanReceiveLiLianReward> logShuShanReceiveLiLianRewardList;
    private static List<LogShuShanEventRecord> logShuShanEventRecordList;
    private static List<LogShuShanExerciseRecord> logShuShanExerciseRecordList;


    // 记忆碎片
    private static List<LogMemoryPiecesLightUp> logMemoryPiecesLightUpList;

    // 绝代双骄
    private static List<LogTwinsDrawKungFu> logTwinsDrawKungFuList;
    private static List<LogTwinsKungFuCombUnlock> logTwinsKungFuCombUnlockList;
    private static List<LogTwinsKungFuUpgrade> logTwinsKungFuUpgradeList;
    private static List<LogTwinsPveBattle> logTwinsPveBattleList;


    private static List<LogWorldCupSkill> logWorldCupSkillList;
    private static List<LogWorldCupKick> logWorldCupKickList;
    private static List<LogWorldCupRecruit> logWorldCupRecruitList;

    //节日自选礼包-购买日志
    private static List<LogActivityFestivalGiftBuy> logActivityFestivalGiftBuyList;

    public static boolean init() {
        logDayLoginList = new ArrayList<>();
        logOnlineNumList = new ArrayList<>();
        logRechargeList = new ArrayList<>();
        logIngotsList = new ArrayList<>();
        logGoodsList = new ArrayList<>();
        logPublishWantedList = new ArrayList<>();
        logTaskActiveRewardList = new ArrayList<>();
        logTaskRewardList = new ArrayList<>();
        logBeautyUpgradeList = new ArrayList<>();
        logEstateFloorRiseRewardList = new ArrayList<>();
        logUnionBuildingList = new ArrayList<>();
        logMineWarRewardList = new ArrayList<>();
        logOreWarRewardList = new ArrayList<>();
        logSacrificeKillList = new ArrayList<>();
        logSacrificeDamageRankRewardList = new ArrayList<>();
        logCommonActivityScoreList = new ArrayList<>();
        logCommonActivityUseGoodsList = new ArrayList<>();
        logTrystActivityUseGoodsList = new ArrayList<>();
        logCommonActivityRankRewardList = new ArrayList<>();
        logOreWarActivityRankRewardList = new ArrayList<>();
        logSacrificeAttackList = new ArrayList<>();
        logUseAddAttributeGoodsList = new ArrayList<>();
        logMammonWorshipList = new ArrayList<>();
        logMammonCongratulateList = new ArrayList<>();
        logWorshipList = new ArrayList<>();
        logEstateWorshipList = new ArrayList<>();
        logEstateWineList = new ArrayList<>();
        logCommonActivityGoodsAutoConsumeList = new ArrayList<>();
        logTitleUpgradeBagList = new ArrayList<>();
        logTitleUpgradeBeautyList = new ArrayList<>();
        logTitleUpgradeBuildingList = new ArrayList<>();
        logTitleUpgradeChildList = new ArrayList<>();
        logTitleUpgradePatronsList = new ArrayList<>();
        logTitleUpgradeVehicleList = new ArrayList<>();
        logTitleUpgradeTravelList = new ArrayList<>();
        logTitleUpgradeTradeWarList = new ArrayList<>();
        logTitleUpgradeRelativesList = new ArrayList<>();
        logUnionParergonList = new ArrayList<>();
        logGetPassTransportList = new ArrayList<>();
        logSecretVolumeIntegrals = new ArrayList<>();
        logEarnSpeedFundList = new ArrayList<>();
        LogActivityDisperseGoldList = new ArrayList<>();
        logActivityDispGoldClientResultList = new ArrayList<>();
        logChildAddEarnSpeedList = new ArrayList<>();
        logWishPoolValueList = new ArrayList<>();

        logThirdRechargeDoubleList = new ArrayList<>();
        logPlatFormUserLoginTimeList = new ArrayList<>();
        logVarietyDispatchList = new ArrayList<>();
        logVarietyRankList = new ArrayList<>();
        logBaiYeGetList = new ArrayList<>();
        logBusyFarmingHarvestList = new ArrayList<>();
        logBusyFarmingWateringList = new ArrayList<>();
        logBusyFarmingLandBuyList = new ArrayList<>();
        logBusyFarmingPlantList = new ArrayList<>();
        logBusyFarmingQuickenList = new ArrayList<>();
        logBusyFarmingRemoveList = new ArrayList<>();
        logBusyFarmingStealList = new ArrayList<>();
        logPawnshopUpgradeList = new ArrayList<>();
        logPawnshopPoliticsList = new ArrayList<>();
        logPawnshopRepairList = new ArrayList<>();
        logPawnshopFakeList = new ArrayList<>();
        logPawnshopCoinList = new ArrayList<>();
        logPawnshopItemList = new ArrayList<>();

        logSkinVolumeEmbroideryFixList = new ArrayList<>();
        logSkinVolumePiecesGetList = new ArrayList<>();
        logThiefRewardList = new ArrayList<>();

        logUnionChamberDispatchList = new ArrayList<>();

        logManorHarvestList = new ArrayList<>();
        logManorSpecialSkillLvUpList = new ArrayList<>();
        logManorSkinLvUpList = new ArrayList<>();
        logManorGuestUnLockList = new ArrayList<>();
        logManorTechnologySkillLvUpList = new ArrayList<>();
        logManorProsperousValueGetList = new ArrayList<>();
        logManorOutPutLvUpList = new ArrayList<>();
        logXiaYueSearchList = new ArrayList<>();

        logCelebrationProcessList = new ArrayList<>();
        logCelebrationFestiveChangeList = new ArrayList<>();

        logLanRuoSiEliminate1List = new ArrayList<>();
        logLanRuoSiEliminate2List = new ArrayList<>();
        logLanRuoSiEnergyList = new ArrayList<>();


        logTreasureFindList = new ArrayList<>();

        logGourdChildMopUpList = new ArrayList<>();
        logGourdChildDrawList = new ArrayList<>();

        logGourdPlantWateringList = new ArrayList<>();

        logMonopolyMarketUserPhysicalChangeLogDataList = new ArrayList<>();
        logMonopolyMarketFortressDispatchLogDataList = new ArrayList<>();
        logMonopolyMarketOfficeUserSeatLogDataList = new ArrayList<>();

        logWinterLoveDigList = new ArrayList<>();
        logWinterLovePickUpItemList = new ArrayList<>();
        logWinterLoveConvertRewardList = new ArrayList<>();


        logHellNpcList = new ArrayList<>();

        logManorWeatherList = new ArrayList<>();

        logGoodBanquetRecordList = new ArrayList<>();

        logShuiHuYeZiCardBattlerResultRecordList = new ArrayList<>();
        logShuiHuYeZiCardGetCardList = new ArrayList<>();
        logShuiHuYeZiCardPVEBattlerRoundRecordList = new ArrayList<>();



        logToyHouseOrderList = new ArrayList<>();
        logToyHouseEliminateList = new ArrayList<>();
        logToyHouseCandyList = new ArrayList<>();

        logShuShanBuildUpList = new ArrayList<>();
        logShuShanGetDiscipleList = new ArrayList<>();
        logShuShanKickOutDiscipleList = new ArrayList<>();
        logShuShanReceiveLiLianRewardList = new ArrayList<>();
        logShuShanEventRecordList = new ArrayList<>();
        logShuShanExerciseRecordList = new ArrayList<>();

        logMemoryPiecesLightUpList = new ArrayList<>();


        logTwinsDrawKungFuList = new ArrayList<>();
        logTwinsKungFuCombUnlockList = new ArrayList<>();
        logTwinsKungFuUpgradeList = new ArrayList<>();
        logTwinsPveBattleList = new ArrayList<>();

        logWorldCupSkillList = new ArrayList<>();
        logWorldCupKickList = new ArrayList<>();
        logWorldCupRecruitList = new ArrayList<>();

        logActivityFestivalGiftBuyList = new ArrayList<>();

        return true;
    }

    public static boolean saveServerDb() {
        saveLogDayLogin();
        saveLogOnlineNum();
        saveLogRecharge();
        return true;
    }

    /**
     * 定时保存
     */
    public static boolean save() {
        saveLogIngots();
        saveLogGoods();
        saveLogPublishWanted();
        saveLogTaskActiveReward();
        saveLogTaskReward();
        saveLogBeautyUpgrade();
        saveLogEstateFloorRiseReward();
        saveLogUnionBuilding();
        saveLogMineWarReward();
        saveLogOreWarReward();
        saveLogSacrificeKill();
        saveLogSacrificeDamageRankReward();
        saveLogCommonActivityScore();
        saveLogCommonActivityUseGoods();
        saveLogTrystActivityUseGoods();
        saveLogCommonActivityRankReward();
        saveLogOreWarActivityRankReward();
        saveLogSacrificeAttack();
        saveLogUseAddAttributeGoods();
        saveLogMammonWorship();
        saveLogMammonCongratulate();
        saveLogWorship();
        saveLogEstateWorship();
        saveLogEstateWine();
        saveLogCommonActivityGoodsAutoConsume();
        saveLogTitleUpgradeBag();
        saveLogTitleUpgradeBeauty();
        saveLogTitleUpgradeBuilding();
        saveLogTitleUpgradeChild();
        saveLogTitleUpgradePatrons();
        saveLogTitleUpgradeVehicle();
        saveLogTitleUpgradeTravel();
        saveLogTitleUpgradeTradeWar();
        saveLogTitleUpgradeRelatives();
        saveLogUnionParergon();
        saveLogGetPassTransport();
        saveLogSecretVolumeIntimacy();
        saveLogEarnSpeedFund();
        saveLogActivityDisperseGoldList();
        saveLogActivityDispGoldClientResultList();
        saveLogChildAddEarnSpeed();
        saveLogWishPoolValueList();

        saveLogThirdRechargeDouble();
        savePlatfomUserLonginTime();
        saveLogVariety();
        saveLogBaiYeGet();
        saveBusyFarming();
        saveLogPawnshopUpgrade();
        saveLogPawnshopPolitics();
        saveLogPawnshopRepair();
        saveLogPawnshopFake();
        saveLogPawnshopCoin();
        saveLogPawnshopItem();
        saveLogSkinVolume();
        saveLogThiefReward();
        saveLogUnionChamberDispatch();
        saveLogManor();
        saveLogXiaYueSearch();
        saveLogCelebration();

        saveLogLanRuoSiEliminate1();
        saveLogLanRuoSiEliminate2();
        saveLogLanRuoSiEnergy();
        saveLogTreasureFind();
        saveLogGourdChild();
        saveLogGourdPlant();
        saveLogMonopolyMarket();
        saveLogWinterLoveDig();
        saveLogWinterLovePickUpItem();
        saveLogWinterLoveConvertReward();
        saveLogHell();

        saveLogGoodBanquet();


        saveLogShuiHuYeZiCard();

        saveLogToyHouseEliminate();
        saveLogToyHouseOrder();
        saveLogToyHouseCandy();

        saveLogShuShan();

        saveLogMemoryPiecesLightUp();


        saveLogTwins();

        saveLogCup();

        //节日自选礼包
        saveLogActivityFestivalGiftBuy();

        return true;
    }

    public static void addLogPawnshopItem(int activityId, long userId, long itemId, int goodsId, long coinBuy, long coinEvaluation, int way){
        LogPawnshopItem log = new LogPawnshopItem(activityId, userId, itemId, goodsId, coinBuy, coinEvaluation, way, System.currentTimeMillis());
        synchronized (logPawnshopItemList){
            logPawnshopItemList.add(log);
        }
    }

    private static void saveLogPawnshopItem(){
        if (!CollectionUtils.isEmpty(logPawnshopItemList)) {
            List<LogPawnshopItem> list;
            synchronized (logPawnshopItemList) {
                list = new ArrayList<>(logPawnshopItemList);
                logPawnshopItemList.clear();
            }
            LogBussiness.addLogPawnshopItemList(list);
        }
    }

    public static void addLogPawnshopCoin(int activityId, long userId, boolean isGet, long coin, long oldCoin, long nowCoin, int way){
        LogPawnshopCoin log = new LogPawnshopCoin(activityId, userId, isGet, coin, oldCoin, nowCoin, way, System.currentTimeMillis());
        synchronized (logPawnshopCoinList){
            logPawnshopCoinList.add(log);
        }
    }

    private static void saveLogPawnshopCoin(){
        if (!CollectionUtils.isEmpty(logPawnshopCoinList)) {
            List<LogPawnshopCoin> list;
            synchronized (logPawnshopCoinList) {
                list = new ArrayList<>(logPawnshopCoinList);
                logPawnshopCoinList.clear();
            }
            LogBussiness.addLogPawnshopCoinList(list);
        }
    }


    public static void addLogPawnshopFake(int activityId, long userId, long itemId, int startReceptionCount, int fakeTime, int fakeLv, long oldPrice, long nowPrice){
        LogPawnshopFake log = new LogPawnshopFake(activityId, userId, itemId, startReceptionCount, fakeTime, fakeLv, oldPrice, nowPrice, System.currentTimeMillis());
        synchronized (logPawnshopFakeList){
            logPawnshopFakeList.add(log);
        }
    }

    private static void saveLogPawnshopFake(){
        if (!CollectionUtils.isEmpty(logPawnshopFakeList)) {
            List<LogPawnshopFake> list;
            synchronized (logPawnshopFakeList) {
                list = new ArrayList<>(logPawnshopFakeList);
                logPawnshopFakeList.clear();
            }
            LogBussiness.addLogPawnshopFakeList(list);
        }
    }

    public static void addLogPawnshopRepair(int activityId, long userId, long itemId, int startReceptionCount, int repairTime, int oldStatus, int nowStatus, long oldPrice, long nowPrice){
        LogPawnshopRepair log = new LogPawnshopRepair(activityId, userId, itemId, startReceptionCount, repairTime, oldStatus, nowStatus, oldPrice, nowPrice, System.currentTimeMillis());
        synchronized (logPawnshopRepairList){
            logPawnshopRepairList.add(log);
        }
    }

    private static void saveLogPawnshopRepair(){
        if (!CollectionUtils.isEmpty(logPawnshopRepairList)) {
            List<LogPawnshopRepair> list;
            synchronized (logPawnshopRepairList) {
                list = new ArrayList<>(logPawnshopRepairList);
                logPawnshopRepairList.clear();
            }
            LogBussiness.addLogPawnshopRepairList(list);
        }
    }

    public static void addLogPawnshopPolitics(int activityId, long userId, int eventId, int addition, int startReceptionCount, int triggerRate){
        LogPawnshopPolitics log = new LogPawnshopPolitics(activityId, userId, eventId, addition, startReceptionCount, triggerRate, System.currentTimeMillis());
        synchronized (logPawnshopPoliticsList){
            logPawnshopPoliticsList.add(log);
        }
    }

    private static void saveLogPawnshopPolitics(){
        if (!CollectionUtils.isEmpty(logPawnshopPoliticsList)) {
            List<LogPawnshopPolitics> list;
            synchronized (logPawnshopPoliticsList) {
                list = new ArrayList<>(logPawnshopPoliticsList);
                logPawnshopPoliticsList.clear();
            }
            LogBussiness.addLogPawnshopPoliticsList(list);
        }
    }

    public static void addLogPawnshopUpgrade(int activityId, long userId, int oldLv, int nowLv, int receptionCount, long upgradeReward){
        LogPawnshopUpgrade log = new LogPawnshopUpgrade(activityId, userId, oldLv, nowLv, receptionCount, upgradeReward, System.currentTimeMillis());
        synchronized (logPawnshopUpgradeList){
            logPawnshopUpgradeList.add(log);
        }
    }

    private static void saveLogPawnshopUpgrade(){
        if (!CollectionUtils.isEmpty(logPawnshopUpgradeList)) {
            List<LogPawnshopUpgrade> list;
            synchronized (logPawnshopUpgradeList) {
                list = new ArrayList<>(logPawnshopUpgradeList);
                logPawnshopUpgradeList.clear();
            }
            LogBussiness.addLogPawnshopUpgradeList(list);
        }
    }

    public static void addLogChildAddEarnSpeed(long userId, String childUid, int type, BigInteger oldEarnSpeed, BigInteger addEarnSpeed, BigInteger nowEarnSpeed){
        LogChildAddEarnSpeed log = new LogChildAddEarnSpeed(userId, childUid, type, oldEarnSpeed, addEarnSpeed, nowEarnSpeed, System.currentTimeMillis());
        synchronized (logChildAddEarnSpeedList){
            logChildAddEarnSpeedList.add(log);
        }
    }

    private static void saveLogChildAddEarnSpeed(){
        if (!CollectionUtils.isEmpty(logChildAddEarnSpeedList)) {
            List<LogChildAddEarnSpeed> list;
            synchronized (logChildAddEarnSpeedList) {
                list = new ArrayList<>(logChildAddEarnSpeedList);
                logChildAddEarnSpeedList.clear();
            }
            LogBussiness.addLogChildAddEarnSpeedList(list);
        }
    }

    public static void addLogEarnSpeedFund(long userId, int type, BigInteger earnSpeed, int titleId, long vipExp, int vipLv){
        LogEarnSpeedFund log = new LogEarnSpeedFund(userId, type, earnSpeed, titleId, vipExp, vipLv, System.currentTimeMillis());
        synchronized (logEarnSpeedFundList) {
            logEarnSpeedFundList.add(log);
        }
    }

    private static void saveLogEarnSpeedFund() {
        if (!CollectionUtils.isEmpty(logEarnSpeedFundList)) {
            List<LogEarnSpeedFund> list;
            synchronized (logEarnSpeedFundList) {
                list = new ArrayList<>(logEarnSpeedFundList);
                logEarnSpeedFundList.clear();
            }
            LogBussiness.addLogEarnSpeedFundList(list);
        }
    }

    public static void addLogTitleUpgradeRelatives(LogTitleUpgradeRelatives log){
        synchronized (logTitleUpgradeRelativesList) {
            logTitleUpgradeRelativesList.add(log);
        }
    }

    private static void saveLogTitleUpgradeRelatives() {
        if (!CollectionUtils.isEmpty(logTitleUpgradeRelativesList)) {
            List<LogTitleUpgradeRelatives> list;
            synchronized (logTitleUpgradeRelativesList) {
                list = new ArrayList<>(logTitleUpgradeRelativesList);
                logTitleUpgradeRelativesList.clear();
            }
            LogBussiness.addLogTitleUpgradeRelativesList(list);
        }
    }

    public static void addLogTitleUpgradeTradeWar(LogTitleUpgradeTradeWar log){
        synchronized (logTitleUpgradeTradeWarList) {
            logTitleUpgradeTradeWarList.add(log);
        }
    }

    private static void saveLogTitleUpgradeTradeWar() {
        if (!CollectionUtils.isEmpty(logTitleUpgradeTradeWarList)) {
            List<LogTitleUpgradeTradeWar> list;
            synchronized (logTitleUpgradeTradeWarList) {
                list = new ArrayList<>(logTitleUpgradeTradeWarList);
                logTitleUpgradeTradeWarList.clear();
            }
            LogBussiness.addLogTitleUpgradeTradeWarList(list);
        }
    }

    public static void addLogTitleUpgradeTravel(LogTitleUpgradeTravel log){
        synchronized (logTitleUpgradeTravelList) {
            logTitleUpgradeTravelList.add(log);
        }
    }

    private static void saveLogTitleUpgradeTravel() {
        if (!CollectionUtils.isEmpty(logTitleUpgradeTravelList)) {
            List<LogTitleUpgradeTravel> list;
            synchronized (logTitleUpgradeTravelList) {
                list = new ArrayList<>(logTitleUpgradeTravelList);
                logTitleUpgradeTravelList.clear();
            }
            LogBussiness.addLogTitleUpgradeTravelList(list);
        }
    }

    public static void addLogTitleUpgradeBag(LogTitleUpgradeBag log){
        synchronized (logTitleUpgradeBagList) {
            logTitleUpgradeBagList.add(log);
        }
    }

    private static void saveLogTitleUpgradeBag() {
        if (!CollectionUtils.isEmpty(logTitleUpgradeBagList)) {
            List<LogTitleUpgradeBag> list;
            synchronized (logTitleUpgradeBagList) {
                list = new ArrayList<>(logTitleUpgradeBagList);
                logTitleUpgradeBagList.clear();
            }
            LogBussiness.addLogTitleUpgradeBagList(list);
        }
    }

    public static void addLogTitleUpgradeBeauty(LogTitleUpgradeBeauty log){
        synchronized (logTitleUpgradeBeautyList) {
            logTitleUpgradeBeautyList.add(log);
        }
    }

    private static void saveLogTitleUpgradeBeauty() {
        if (!CollectionUtils.isEmpty(logTitleUpgradeBeautyList)) {
            List<LogTitleUpgradeBeauty> list;
            synchronized (logTitleUpgradeBeautyList) {
                list = new ArrayList<>(logTitleUpgradeBeautyList);
                logTitleUpgradeBeautyList.clear();
            }
            LogBussiness.addLogTitleUpgradeBeautyList(list);
        }
    }

    public static void addLogTitleUpgradeBuilding(LogTitleUpgradeBuilding log){
        synchronized (logTitleUpgradeBuildingList) {
            logTitleUpgradeBuildingList.add(log);
        }
    }

    private static void saveLogTitleUpgradeBuilding() {
        if (!CollectionUtils.isEmpty(logTitleUpgradeBuildingList)) {
            List<LogTitleUpgradeBuilding> list;
            synchronized (logTitleUpgradeBuildingList) {
                list = new ArrayList<>(logTitleUpgradeBuildingList);
                logTitleUpgradeBuildingList.clear();
            }
            LogBussiness.addLogTitleUpgradeBuildingList(list);
        }
    }

    public static void addLogTitleUpgradeChild(LogTitleUpgradeChild log){
        synchronized (logTitleUpgradeChildList) {
            logTitleUpgradeChildList.add(log);
        }
    }

    private static void saveLogTitleUpgradeChild() {
        if (!CollectionUtils.isEmpty(logTitleUpgradeChildList)) {
            List<LogTitleUpgradeChild> list;
            synchronized (logTitleUpgradeChildList) {
                list = new ArrayList<>(logTitleUpgradeChildList);
                logTitleUpgradeChildList.clear();
            }
            LogBussiness.addLogTitleUpgradeChildList(list);
        }
    }

    public static void addLogTitleUpgradePatrons(LogTitleUpgradePatrons log){
        synchronized (logTitleUpgradePatronsList) {
            logTitleUpgradePatronsList.add(log);
        }
    }

    private static void saveLogTitleUpgradePatrons() {
        if (!CollectionUtils.isEmpty(logTitleUpgradePatronsList)) {
            List<LogTitleUpgradePatrons> list;
            synchronized (logTitleUpgradePatronsList) {
                list = new ArrayList<>(logTitleUpgradePatronsList);
                logTitleUpgradePatronsList.clear();
            }
            LogBussiness.addLogTitleUpgradePatronsList(list);
        }
    }

    public static void addLogTitleUpgradeVehicle(LogTitleUpgradeVehicle log){
        synchronized (logTitleUpgradeVehicleList) {
            logTitleUpgradeVehicleList.add(log);
        }
    }

    private static void saveLogTitleUpgradeVehicle() {
        if (!CollectionUtils.isEmpty(logTitleUpgradeVehicleList)) {
            List<LogTitleUpgradeVehicle> list;
            synchronized (logTitleUpgradeVehicleList) {
                list = new ArrayList<>(logTitleUpgradeVehicleList);
                logTitleUpgradeVehicleList.clear();
            }
            LogBussiness.addLogTitleUpgradeVehicleList(list);
        }
    }

    public static void addLogCommonActivityGoodsAutoConsume(long userId, int goodsId, long count, long goodsModifyTime, String reward){
        LogCommonActivityGoodsAutoConsume log = new LogCommonActivityGoodsAutoConsume(userId, goodsId, count, goodsModifyTime, reward, System.currentTimeMillis());
        synchronized (logCommonActivityGoodsAutoConsumeList) {
            logCommonActivityGoodsAutoConsumeList.add(log);
        }
    }

    private static void saveLogCommonActivityGoodsAutoConsume() {
        if (!CollectionUtils.isEmpty(logCommonActivityGoodsAutoConsumeList)) {
            List<LogCommonActivityGoodsAutoConsume> list;
            synchronized (logCommonActivityGoodsAutoConsumeList) {
                list = new ArrayList<>(logCommonActivityGoodsAutoConsumeList);
                logCommonActivityGoodsAutoConsumeList.clear();
            }
            LogBussiness.addLogCommonActivityGoodsAutoConsumeList(list);
        }
    }

    public static void addLogEstateWine(long userId, boolean isGet, long value, long oldValue, long nowValue, int master, int son){
        LogEstateWine log = new LogEstateWine(userId, isGet, value, oldValue, nowValue, master, son, System.currentTimeMillis());
        synchronized (logEstateWineList) {
            logEstateWineList.add(log);
        }
    }

    private static void saveLogEstateWine() {
        if (!CollectionUtils.isEmpty(logEstateWineList)) {
            List<LogEstateWine> list;
            synchronized (logEstateWineList) {
                list = new ArrayList<>(logEstateWineList);
                logEstateWineList.clear();
            }
            LogBussiness.addLogEstateWineList(list);
        }
    }

    public static void addLogEstateWorship(long userId, int type, String reward){
        LogEstateWorship log = new LogEstateWorship(userId, type, reward, System.currentTimeMillis());
        synchronized (logEstateWorshipList) {
            logEstateWorshipList.add(log);
        }
    }

    private static void saveLogEstateWorship() {
        if (!CollectionUtils.isEmpty(logEstateWorshipList)) {
            List<LogEstateWorship> list;
            synchronized (logEstateWorshipList) {
                list = new ArrayList<>(logEstateWorshipList);
                logEstateWorshipList.clear();
            }
            LogBussiness.addLogEstateWorshipList(list);
        }
    }

    public static void addLogWorship(long userId, int type, int effectMammonSkill, String reward){
        LogWorship log = new LogWorship(userId, type, effectMammonSkill, reward, System.currentTimeMillis());
        synchronized (logWorshipList) {
            logWorshipList.add(log);
        }
    }

    private static void saveLogWorship() {
        if (!CollectionUtils.isEmpty(logWorshipList)) {
            List<LogWorship> list;
            synchronized (logWorshipList) {
                list = new ArrayList<>(logWorshipList);
                logWorshipList.clear();
            }
            LogBussiness.addLogWorshipList(list);
        }
    }

    public static void addLogMammonCongratulate(long userId, String mammonRecordUid, String reward){
        LogMammonCongratulate log = new LogMammonCongratulate(userId, mammonRecordUid, reward, System.currentTimeMillis());
        synchronized (logMammonCongratulateList) {
            logMammonCongratulateList.add(log);
        }
    }

    private static void saveLogMammonCongratulate() {
        if (!CollectionUtils.isEmpty(logMammonCongratulateList)) {
            List<LogMammonCongratulate> list;
            synchronized (logMammonCongratulateList) {
                list = new ArrayList<>(logMammonCongratulateList);
                logMammonCongratulateList.clear();
            }
            LogBussiness.addLogMammonCongratulateList(list);
        }
    }

    public static void addLogMammonWorship(long userId, int mammonSkillId, String reward){
        LogMammonWorship log = new LogMammonWorship(userId, mammonSkillId, reward, System.currentTimeMillis());
        synchronized (logMammonWorshipList) {
            logMammonWorshipList.add(log);
        }
    }

    private static void saveLogMammonWorship() {
        if (!CollectionUtils.isEmpty(logMammonWorshipList)) {
            List<LogMammonWorship> list;
            synchronized (logMammonWorshipList) {
                list = new ArrayList<>(logMammonWorshipList);
                logMammonWorshipList.clear();
            }
            LogBussiness.addLogMammonWorshipList(list);
        }
    }

    public static void addLogUseAddAttributeGoods(long userId, int goodsId, int goodsType, int effectObjectId, long addValue, BigInteger oldValue, BigInteger value, int num){
        LogUseAddAttributeGoods log = new LogUseAddAttributeGoods(userId, goodsId, goodsType, effectObjectId, addValue, oldValue, value, System.currentTimeMillis(), num);
        synchronized (logUseAddAttributeGoodsList) {
            logUseAddAttributeGoodsList.add(log);
        }
    }

    private static void saveLogUseAddAttributeGoods() {
        if (!CollectionUtils.isEmpty(logUseAddAttributeGoodsList)) {
            List<LogUseAddAttributeGoods> list;
            synchronized (logUseAddAttributeGoodsList) {
                list = new ArrayList<>(logUseAddAttributeGoodsList);
                logUseAddAttributeGoodsList.clear();
            }
            LogBussiness.addLogUseAddAttributeGoodsList(list);
        }
    }

    public static void addLogSacrificeAttack(long userId, long dateMark, int bossLevel, BigInteger oldBlood, BigInteger bossBlood, int patronsId, BigInteger damage, String reward){
        LogSacrificeAttack log = new LogSacrificeAttack(userId, dateMark, bossLevel, oldBlood, bossBlood, patronsId, damage, reward, System.currentTimeMillis());
        synchronized (logSacrificeAttackList) {
            logSacrificeAttackList.add(log);
        }
    }

    private static void saveLogSacrificeAttack() {
        if (!CollectionUtils.isEmpty(logSacrificeAttackList)) {
            List<LogSacrificeAttack> list;
            synchronized (logSacrificeAttackList) {
                list = new ArrayList<>(logSacrificeAttackList);
                logSacrificeAttackList.clear();
            }
            LogBussiness.addLogSacrificeAttackList(list);
        }
    }

    public static void addLogCommonActivityRankReward(long userId, int activityId, int type, int rank, String reward){
        LogCommonActivityRankReward log = new LogCommonActivityRankReward(userId, activityId, type, rank, reward, System.currentTimeMillis());
        synchronized (logCommonActivityRankRewardList) {
            logCommonActivityRankRewardList.add(log);
        }
    }

    public static void addLogOreWarActivityRankReward(long userId, int activityId, int type, int rank, String reward){
        LogOreWarActivityRankReward log = new LogOreWarActivityRankReward(userId, activityId, type, rank, reward, System.currentTimeMillis());
        synchronized (logOreWarActivityRankRewardList) {
            logOreWarActivityRankRewardList.add(log);
        }
    }

    private static void saveLogCommonActivityRankReward() {
        if (!CollectionUtils.isEmpty(logCommonActivityRankRewardList)) {
            List<LogCommonActivityRankReward> list;
            synchronized (logCommonActivityRankRewardList) {
                list = new ArrayList<>(logCommonActivityRankRewardList);
                logCommonActivityRankRewardList.clear();
            }
            LogBussiness.addLogCommonActivityRankRewardList(list);
        }
    }

    private static void saveLogOreWarActivityRankReward() {
        if (!CollectionUtils.isEmpty(logOreWarActivityRankRewardList)) {
            List<LogOreWarActivityRankReward> list;
            synchronized (logOreWarActivityRankRewardList) {
                list = new ArrayList<>(logOreWarActivityRankRewardList);
                logOreWarActivityRankRewardList.clear();
            }
            LogBussiness.addLogOreWarActivityRankRewardList(list);
        }
    }

    public static void addLogCommonActivityUseGoods(long userId, int activityId, int goodsId, long value, long oldValue, long nowValue, String reward){
        LogCommonActivityUseGoods log = new LogCommonActivityUseGoods(userId, activityId, goodsId, value, oldValue, nowValue, reward, System.currentTimeMillis());
        synchronized (logCommonActivityUseGoodsList) {
            logCommonActivityUseGoodsList.add(log);
        }
    }

    public static void addLogTrystActivityUseGoods(long userId, int activityId, int goodsId, long value, long oldValue, long nowValue, String reward){
        LogTrystActivityUseGoods log = new LogTrystActivityUseGoods(userId, activityId, goodsId, value, oldValue, nowValue, reward, System.currentTimeMillis());
        synchronized (logTrystActivityUseGoodsList) {
            logTrystActivityUseGoodsList.add(log);
        }
    }

    private static void saveLogCommonActivityUseGoods() {
        if (!CollectionUtils.isEmpty(logCommonActivityUseGoodsList)) {
            List<LogCommonActivityUseGoods> list;
            synchronized (logCommonActivityUseGoodsList) {
                list = new ArrayList<>(logCommonActivityUseGoodsList);
                logCommonActivityUseGoodsList.clear();
            }
            LogBussiness.addLogCommonActivityUseGoodsList(list);
        }
    }
    private static void saveLogTrystActivityUseGoods() {
        if (!CollectionUtils.isEmpty(logTrystActivityUseGoodsList)) {
            List<LogTrystActivityUseGoods> list;
            synchronized (logTrystActivityUseGoodsList) {
                list = new ArrayList<>(logTrystActivityUseGoodsList);
                logTrystActivityUseGoodsList.clear();
            }
            LogBussiness.addLogTrystActivityUseGoodsList(list);
        }
    }

    public static void addLogCommonActivityScore(long userId, int activityId, int scoreGoodsId, boolean isGet, long value, long oldValue, long nowValue, int master, int son){
        LogCommonActivityScore log = new LogCommonActivityScore(userId, activityId, scoreGoodsId, isGet, value, oldValue, nowValue, master, son, System.currentTimeMillis());
        synchronized (logCommonActivityScoreList) {
            logCommonActivityScoreList.add(log);
        }
    }

    private static void saveLogCommonActivityScore() {
        if (!CollectionUtils.isEmpty(logCommonActivityScoreList)) {
            List<LogCommonActivityScore> list;
            synchronized (logCommonActivityScoreList) {
                list = new ArrayList<>(logCommonActivityScoreList);
                logCommonActivityScoreList.clear();
            }
            LogBussiness.addLogCommonActivityScoreList(list);
        }
    }

    public static void addLogSacrificeDamageRankReward(long userId, long dateMark, int rank, BigInteger damage, String reward){
        LogSacrificeDamageRankReward log = new LogSacrificeDamageRankReward(userId, dateMark, rank, damage, reward, System.currentTimeMillis());
        synchronized (logSacrificeDamageRankRewardList) {
            logSacrificeDamageRankRewardList.add(log);
        }
    }

    private static void saveLogSacrificeDamageRankReward() {
        if (!CollectionUtils.isEmpty(logSacrificeDamageRankRewardList)) {
            List<LogSacrificeDamageRankReward> list;
            synchronized (logSacrificeDamageRankRewardList) {
                list = new ArrayList<>(logSacrificeDamageRankRewardList);
                logSacrificeDamageRankRewardList.clear();
            }
            LogBussiness.addLogSacrificeDamageRankRewardList(list);
        }
    }

    public static void addLogSacrificeKill(long userId, long dateMark, int bossLevel, String reward){
        LogSacrificeKill log = new LogSacrificeKill(userId, dateMark, bossLevel, reward, System.currentTimeMillis());
        synchronized (logSacrificeKillList) {
            logSacrificeKillList.add(log);
        }
    }

    private static void saveLogSacrificeKill() {
        if (!CollectionUtils.isEmpty(logSacrificeKillList)) {
            List<LogSacrificeKill> list;
            synchronized (logSacrificeKillList) {
                list = new ArrayList<>(logSacrificeKillList);
                logSacrificeKillList.clear();
            }
            LogBussiness.addLogSacrificeKillList(list);
        }
    }

    public static void addLogGetTransport(long userId, int tpId, int master, int son,int isGet){
        LogGetPassTransport log = new LogGetPassTransport(userId, tpId, master, son, System.currentTimeMillis(),isGet);
        synchronized (logGetPassTransportList) {
            logGetPassTransportList.add(log);
        }
    }

    private static void saveLogGetPassTransport() {
        if (!CollectionUtils.isEmpty(logGetPassTransportList)) {
            List<LogGetPassTransport> list;
            synchronized (logGetPassTransportList) {
                list = new ArrayList<>(logGetPassTransportList);
                logGetPassTransportList.clear();
            }
            LogBussiness.addLogGetPassTransportList(list);
        }
    }

    public static void addLogMineWarReward(long userId, int mineType, int pitId, String reward, long rewardTime, boolean isRefuge, int son){
        LogMineWarReward log = new LogMineWarReward(userId, mineType, pitId, reward, rewardTime, isRefuge, son, System.currentTimeMillis());
        synchronized (logMineWarRewardList) {
            logMineWarRewardList.add(log);
        }
    }

    public static void addLogOreWarReward(long userId, int activityId, int pitId, String reward, long rewardTime, boolean isRefuge, int son){
        LogOreWarReward log = new LogOreWarReward(userId, activityId, pitId, reward, rewardTime, isRefuge, son, System.currentTimeMillis());
        synchronized (logOreWarRewardList) {
            logOreWarRewardList.add(log);
        }
    }

    private static void saveLogMineWarReward() {
        if (!CollectionUtils.isEmpty(logMineWarRewardList)) {
            List<LogMineWarReward> list;
            synchronized (logMineWarRewardList) {
                list = new ArrayList<>(logMineWarRewardList);
                logMineWarRewardList.clear();
            }
            LogBussiness.addLogMineWarRewardList(list);
        }
    }

    private static void saveLogOreWarReward() {
        if (!CollectionUtils.isEmpty(logOreWarRewardList)) {
            List<LogOreWarReward> list;
            synchronized (logOreWarRewardList) {
                list = new ArrayList<>(logOreWarRewardList);
                logOreWarRewardList.clear();
            }
            LogBussiness.addLogOreWarRewardList(list);
        }
    }


    public static void addLogActivityReward(long userId, int activityId, int activityType, int childType, int conditionId, int rank, boolean isAuto, String reward){
        AutoLogMgr.add(new LogActivityReward(userId, activityId, activityType, childType, conditionId, rank, isAuto, reward));
    }

    public static void addLogDayLogin(long userId, long registerTime, long time, long serverId) {
        LogDayLogin logDayLogin = new LogDayLogin();
        logDayLogin.setUserId(userId);
        logDayLogin.setServerId(serverId);
        logDayLogin.setRegisterTime(registerTime);
        logDayLogin.setTime(time);
        synchronized (logDayLoginList) {
            logDayLoginList.add(logDayLogin);
        }
    }

    public static void addLogOnlineNum(long serverId, int onlineNum, long time) {
        LogOnlineNum logOnlineNum = new LogOnlineNum();
        logOnlineNum.setCount(onlineNum);
        logOnlineNum.setServerId(serverId);
        logOnlineNum.setTime(time);
        synchronized (logOnlineNumList) {
            logOnlineNumList.add(logOnlineNum);
        }
    }

    public static void addLogRecharge(long userId, int mallId, int num, long price, String orderNo, long serverId, int type, String sdkOrderNo,
           long vipExp, String activityType, String currency, String realMoney, String realCurrency, String localMoney, String localCurrency,
           String ltrRate, String newMoney, String tax, long productCoin, int device, String payChannel, String platformOrderNo, int activityId,
           String couponMoney, int mallMarkId, boolean isRepeatBuy) {
        LogRecharge log = new LogRecharge(userId, mallId, num, price, orderNo, System.currentTimeMillis(), serverId, type, sdkOrderNo,
                vipExp, activityType, currency, realMoney, realCurrency, localMoney, localCurrency, ltrRate, newMoney, tax, productCoin,
                device, payChannel, platformOrderNo, activityId, couponMoney, mallMarkId, isRepeatBuy);
        if(OrderHelper.isTokensOrder(sdkOrderNo)){//代币订单
            log.setOrderType(1);
        }
        synchronized (logRechargeList) {
            logRechargeList.add(log);
        }
    }

    public static void addLogIngots(long userId, long ingots, boolean isGet, eLogMoneyType master, eLogMoneyType son,
                                    long originalIngots, long nowIngots, String desc, long vipExp) {
        LogIngots log = new LogIngots(userId, ingots, isGet, master.getValue(), son.getValue(), originalIngots, nowIngots, desc, vipExp);
        synchronized (logIngotsList) {
            logIngotsList.add(log);
        }
    }

    public static void addLogGoods(int goodsId, long userId, boolean get, long num, long nowNum, eLogMoneyType removeType, long vipExp) {
        addLogGoods(goodsId, userId, get, num, nowNum, removeType, "", vipExp);
    }

    public static void addLogGoods(int goodsId, long userId, boolean get, long num, long nowNum, eLogMoneyType removeType, String param, long vipExp) {
        LogGoods log = new LogGoods(goodsId, userId, get, num, nowNum, removeType.getValue(), param, vipExp);
        synchronized (logGoodsList) {
            logGoodsList.add(log);
        }
    }

    public static void addLogPublishWanted(long userId, long wantedUserId, String consume, long wantedTime){
        LogPublishWanted log = new LogPublishWanted(userId, wantedUserId, consume, wantedTime * 1000);
        synchronized (logPublishWantedList) {
            logPublishWantedList.add(log);
        }
    }

    public static void addLogTaskActiveReward(long userId, int active, int activeIndex, String reward, boolean isSevenDay){
        LogTaskActiveReward log = new LogTaskActiveReward(userId, active, activeIndex, reward, isSevenDay, System.currentTimeMillis());
        synchronized (logTaskActiveRewardList) {
            logTaskActiveRewardList.add(log);
        }
    }

    public static void addLogTaskReward(long userId, int taskId, int addActive, String reward){
        LogTaskReward log = new LogTaskReward(userId, taskId, addActive, reward, System.currentTimeMillis());
        synchronized (logTaskRewardList) {
            logTaskRewardList.add(log);
        }
    }

    public static void addLogBeautyUpgrade(long userId, int beautyId,int type, int oldLv, int level, String consume){
        LogBeautyUpgrade log = new LogBeautyUpgrade(userId, beautyId,type, oldLv, level, consume, System.currentTimeMillis());
        synchronized (logBeautyUpgradeList) {
            logBeautyUpgradeList.add(log);
        }
    }



    public static void addLogEstateFloorRiseReward(long userId, int riseFloorCount, int maxType, int maxPos, String reward){
        LogEstateFloorRiseReward log = new LogEstateFloorRiseReward(userId, riseFloorCount, maxType, maxPos, reward, System.currentTimeMillis());
        synchronized (logEstateFloorRiseRewardList) {
            logEstateFloorRiseRewardList.add(log);
        }
    }

    public static void addLogUnionBuilding(long userId, String unionUid, int buildingType, long exp, long originalExp, long nowExp, int buildingLv){
        LogUnionBuilding log = new LogUnionBuilding(userId, unionUid, buildingType, exp, originalExp, nowExp, buildingLv, System.currentTimeMillis());
        synchronized (logUnionBuildingList) {
            logUnionBuildingList.add(log);
        }
    }

    public static void addLogSecretVolumeIntegral(long userId, long originalIntegral, long nowIntegral, long addIntegral, int master, int son){
        LogSecretVolumeIntegral log = new LogSecretVolumeIntegral(userId, originalIntegral, nowIntegral, addIntegral, System.currentTimeMillis(), master, son);
        synchronized (logSecretVolumeIntegrals) {
            logSecretVolumeIntegrals.add(log);
        }
    }

    private static void saveLogUnionBuilding() {
        if (!CollectionUtils.isEmpty(logUnionBuildingList)) {
            List<LogUnionBuilding> list;
            synchronized (logUnionBuildingList) {
                list = new ArrayList<>(logUnionBuildingList);
                logUnionBuildingList.clear();
            }
            LogBussiness.addLogUnionBuildingList(list);
        }
    }

    private static void saveLogDayLogin() {
        if (!CollectionUtils.isEmpty(logDayLoginList)) {
            List<LogDayLogin> list;
            synchronized (logDayLoginList) {
                list = new ArrayList<>(logDayLoginList);
                logDayLoginList.clear();
            }
            LogBussiness.addLogDayLoginList(list);
        }
    }

    private static void saveLogOnlineNum() {
        if (!CollectionUtils.isEmpty(logOnlineNumList)) {
            List<LogOnlineNum> list;
            synchronized (logOnlineNumList) {
                list = new ArrayList<>(logOnlineNumList);
                logOnlineNumList.clear();
            }
            LogBussiness.addLogOnlineNumList(list);
        }
    }


    private static void saveLogRecharge() {
        if (!CollectionUtils.isEmpty(logRechargeList)) {
            List<LogRecharge> list;
            synchronized (logRechargeList) {
                list = new ArrayList<>(logRechargeList);
                logRechargeList.clear();
            }
            LogBussiness.addLogRechargeList(list);
        }
    }

    private static void saveLogIngots() {
        if (!CollectionUtils.isEmpty(logIngotsList)) {
            List<LogIngots> list;
            synchronized (logIngotsList) {
                list = new ArrayList<>(logIngotsList);
                logIngotsList.clear();
            }
            for (LogIngots logIngots : list) {
                AutoLogMgr.add(logIngots);
            }

            try {
                //发送到kafka
                Producer<String, String> producer = KafKaHelper.getProducer();
                if (!(producer instanceof EmptyProducer)) {
                    String serverId = ConfigHelper.getValue("serverId");
                    for (LogIngots log : list) {
                        if (log.isGet()) {
                            //先一个一个发，有缓存的
                            LogGoodsEntity logGoodsEntity = new LogGoodsEntity(GameConfig.GAME_MONEY_INGOTS, log.getUserId(), new Date(log.getTime()), true, log.getIngots(), log.getSon(), log.getVipExp());
                            producer.send(new ProducerRecord<>("dzg_get_goods_log", serverId, JSON.toJSONString(logGoodsEntity)));
                        }
                    }
                    producer.flush();
                }else {
                    //通过http请求, 丢了就算了
                    String logCollectHttp = ChannelConfig.GOODS_GET_LOG_COLLECT_HTTP;
                    if(!StringUtils.isNullOrEmpty(logCollectHttp)){
                        List<LogGoodsEntity> gotList = new ArrayList<>();
                        for (LogIngots log : list) {
                            if (log.isGet()) {
                                LogGoodsEntity logGoodsEntity = new LogGoodsEntity(GameConfig.GAME_MONEY_INGOTS, log.getUserId(), new Date(log.getTime()), true, log.getIngots(), log.getSon(), log.getVipExp());
                                gotList.add(logGoodsEntity);
                            }
                        }
                        sendGoodsGetCollect(logCollectHttp, gotList);
                    }
                }
            }catch (Exception e){
                TempMgr.getLogger().error("", e);
            }
        }
    }

    private static void saveLogGoods() {
        if (!CollectionUtils.isEmpty(logGoodsList)) {
            List<LogGoods> list;
            synchronized (logGoodsList) {
                list = new ArrayList<>(logGoodsList);
                logGoodsList.clear();
            }

            for (LogGoods logGoods : list) {
                AutoLogMgr.add(logGoods);
            }

            try {
                //发送到kafka
                Producer<String, String> producer = KafKaHelper.getProducer();
                if (!(producer instanceof EmptyProducer)) {
                    String serverId = ConfigHelper.getValue("serverId");
                    for (LogGoods log : list) {
                        if (log.getType()) {
                            //先一个一个发，有缓存的
                            LogGoodsEntity logGoodsEntity = new LogGoodsEntity(log.getGoodsId(), log.getUserId(), new Date(log.getTime()), log.getType(), log.getNum(), log.getWay(), log.getVipExp());
                            producer.send(new ProducerRecord<>("dzg_get_goods_log", serverId, JSON.toJSONString(logGoodsEntity)));
                        }
                    }
                    producer.flush();
                }else {
                    //通过http请求, 丢了就算了
                    String logCollectHttp = ChannelConfig.GOODS_GET_LOG_COLLECT_HTTP;
                    if(!StringUtils.isNullOrEmpty(logCollectHttp)){
                        List<LogGoodsEntity> gotList = new ArrayList<>();
                        for (LogGoods log : list) {
                            if (log.getType()) {
                                LogGoodsEntity logGoodsEntity = new LogGoodsEntity(log.getGoodsId(), log.getUserId(), new Date(log.getTime()), log.getType(), log.getNum(), log.getWay(), log.getVipExp());
                                gotList.add(logGoodsEntity);
                            }
                        }
                        sendGoodsGetCollect(logCollectHttp, gotList);
                    }
                }
            }catch (Exception e){
                TempMgr.getLogger().error("", e);
            }
        }
    }

    public static void sendGoodsGetCollect(String logCollectHttp, List<LogGoodsEntity> gotList) {
        if(gotList.isEmpty()){
            return;
        }
        Map<String, String> result = HttpHelper.httpPostJson(logCollectHttp, JSON.toJSONString(gotList), "UTF-8", null, 5000, 5000, 5000);
        String code = result.getOrDefault("code", "0");
        if(!"200".equals(code)){
            TempMgr.getLogger().error("道具获得日志推送失败");
        }else {

        }
    }

    private static void saveLogPublishWanted(){
        if (!CollectionUtils.isEmpty(logPublishWantedList)){
            List<LogPublishWanted> list;
            synchronized (logPublishWantedList){
                list = new ArrayList<>(logPublishWantedList);
                logPublishWantedList.clear();
            }
            LogBussiness.addLogPublishWantedList(list);
        }
    }

    private static void saveLogTaskActiveReward(){
        if (!CollectionUtils.isEmpty(logTaskActiveRewardList)){
            List<LogTaskActiveReward> list;
            synchronized (logTaskActiveRewardList){
                list = new ArrayList<>(logTaskActiveRewardList);
                logTaskActiveRewardList.clear();
            }
            LogBussiness.addLogTaskActiveRewardList(list);
        }
    }

    private static void saveLogTaskReward(){
        if (!CollectionUtils.isEmpty(logTaskRewardList)){
            List<LogTaskReward> list;
            synchronized (logTaskRewardList){
                list = new ArrayList<>(logTaskRewardList);
                logTaskRewardList.clear();
            }
            LogBussiness.addLogTaskRewardList(list);
        }
    }

    private static void saveLogBeautyUpgrade(){
        if (!CollectionUtils.isEmpty(logBeautyUpgradeList)){
            List<LogBeautyUpgrade> list;
            synchronized (logBeautyUpgradeList){
                list = new ArrayList<>(logBeautyUpgradeList);
                logBeautyUpgradeList.clear();
            }
            LogBussiness.addLogBeautyUpgradeList(list);
        }
    }


    private static void saveLogEstateFloorRiseReward(){
        if (!CollectionUtils.isEmpty(logEstateFloorRiseRewardList)){
            List<LogEstateFloorRiseReward> list;
            synchronized (logEstateFloorRiseRewardList){
                list = new ArrayList<>(logEstateFloorRiseRewardList);
                logEstateFloorRiseRewardList.clear();
            }
            LogBussiness.addLogEstateFloorRiseRewardList(list);
        }
    }

    private static void saveLogSecretVolumeIntimacy(){
        if (!CollectionUtils.isEmpty(logSecretVolumeIntegrals)){
            List<LogSecretVolumeIntegral> list;
            synchronized (logSecretVolumeIntegrals){
                list = new ArrayList<>(logSecretVolumeIntegrals);
                logSecretVolumeIntegrals.clear();
            }
            LogBussiness.addLogSecretVolumeIntegralList(list);
        }
    }

    public static void addLogUnionParergon(long userId, String unionUid, int parergonId, int progress, boolean isFinish, boolean hasBussinessman){
        LogUnionParergon log = new LogUnionParergon(userId, unionUid, parergonId, progress, isFinish, hasBussinessman, System.currentTimeMillis());
        synchronized (logUnionParergonList) {
            logUnionParergonList.add(log);
        }
    }

    private static void saveLogUnionParergon(){
        if (!CollectionUtils.isEmpty(logUnionParergonList)){
            List<LogUnionParergon> list;
            synchronized (logUnionParergonList){
                list = new ArrayList<>(logUnionParergonList);
                logUnionParergonList.clear();
            }
            LogBussiness.addLogUnionParergonList(list);
        }
    }

    public static void addLogActivityDisperseGold(long userId, int activityId){
        LogActivityDisperseGold log = new LogActivityDisperseGold(userId, activityId, System.currentTimeMillis());
        synchronized (LogActivityDisperseGoldList) {
            LogActivityDisperseGoldList.add(log);
        }
    }

    private static void saveLogActivityDisperseGoldList(){
        if (!CollectionUtils.isEmpty(LogActivityDisperseGoldList)){
            List<LogActivityDisperseGold> list;
            synchronized (LogActivityDisperseGoldList){
                list = new ArrayList<>(LogActivityDisperseGoldList);
                LogActivityDisperseGoldList.clear();
            }
            LogBussiness.addLogActivityDisperseGoldList(list);
        }
    }

    public static void addLogActivityDispGoldClientResult(long disperseId, long userId, int activityId, int activityType, int resultType, long actionTime, String reward){
        LogActivityDispGoldClientResult log = new LogActivityDispGoldClientResult(disperseId, userId, activityId, activityType, resultType, actionTime, reward, System.currentTimeMillis());
        synchronized (logActivityDispGoldClientResultList){
            logActivityDispGoldClientResultList.add(log);
        }
    }

    private static void saveLogActivityDispGoldClientResultList(){
        if (!CollectionUtils.isEmpty(logActivityDispGoldClientResultList)){
            List<LogActivityDispGoldClientResult>  list;
            synchronized (logActivityDispGoldClientResultList){
                list = new ArrayList<>(logActivityDispGoldClientResultList);
                logActivityDispGoldClientResultList.clear();
            }
            LogBussiness.addLogActivityDispGoldClientResultList(list);
        }
    }

    public static void addLogWishPoolValue(int activityId, long userId, int addValue, int totalValue) {
        LogWishPoolValue log = new LogWishPoolValue(activityId, userId, addValue, totalValue, System.currentTimeMillis());
        synchronized (logWishPoolValueList) {
            logWishPoolValueList.add(log);
        }
    }

    private static void saveLogWishPoolValueList() {
        if (!CollectionUtils.isEmpty(logWishPoolValueList)) {
            List<LogWishPoolValue> tmpList;
            synchronized (logWishPoolValueList) {
                tmpList = new ArrayList<>(logWishPoolValueList);
                logWishPoolValueList.clear();
            }
            LogBussiness.addLogWishPoolValueList(tmpList);
        }
    }

    public static void addLogThirdRechargeDouble(long userId, String orderNo, String sdkOrderNo, int mallId, String reward) {
        LogThirdRechargeDouble log = new LogThirdRechargeDouble(userId, orderNo, sdkOrderNo, mallId, reward, System.currentTimeMillis());
        synchronized (logThirdRechargeDoubleList) {
            logThirdRechargeDoubleList.add(log);
        }
    }

    private static void saveLogThirdRechargeDouble() {
        if (!CollectionUtils.isEmpty(logThirdRechargeDoubleList)) {
            List<LogThirdRechargeDouble> list;
            synchronized (logThirdRechargeDoubleList) {
                list = new ArrayList<>(logThirdRechargeDoubleList);
                logThirdRechargeDoubleList.clear();
            }
            LogBussiness.addLogThirdRechargeDoubleList(list);
        }
    }

    public static void updatePlatfomUserLonginTime(String openId) {
        synchronized (logPlatFormUserLoginTimeList) {
            logPlatFormUserLoginTimeList.add(openId);
        }
    }

    private static void savePlatfomUserLonginTime() {
        if (!CollectionUtils.isEmpty(logPlatFormUserLoginTimeList)) {
            List<String> list;
            synchronized (logPlatFormUserLoginTimeList) {
                list = new ArrayList<>(logPlatFormUserLoginTimeList);
                logPlatFormUserLoginTimeList.clear();
            }
            long nowTime = System.currentTimeMillis();
            for (String openId : list) {
                PlatformUserIdInfoBussiness.updateLoginTime(openId,nowTime);
            }
        }
    }

    public static void addLogVarietyDispatch(LogVarietyDispatch logVarietyDispatch) {
        synchronized (logVarietyDispatchList) {
            logVarietyDispatchList.add(logVarietyDispatch);
        }
    }

    public static void addLogVarietyRank(LogVarietyRank logVarietyRank) {
        synchronized (logVarietyRankList) {
            logVarietyRankList.add(logVarietyRank);
        }
    }

    private static void saveLogVariety() {
        if (!CollectionUtils.isEmpty(logVarietyDispatchList)) {
            List<LogVarietyDispatch> list;
            synchronized (logVarietyDispatchList) {
                list = new ArrayList<>(logVarietyDispatchList);
                logVarietyDispatchList.clear();
            }
            LogBussiness.addLogVarietyDispatch(list);
        }

        if (!CollectionUtils.isEmpty(logVarietyRankList)) {
            List<LogVarietyRank> list;
            synchronized (logVarietyRankList) {
                list = new ArrayList<>(logVarietyRankList);
                logVarietyRankList.clear();
            }
            LogBussiness.addLogVarietyRank(list);
        }
    }

    public static void addLogBaiYeGet(LogBaiYeGet logBaiYeGet) {
        synchronized (logBaiYeGetList) {
            logBaiYeGetList.add(logBaiYeGet);
        }
    }


    private static void saveLogBaiYeGet() {
        if (!CollectionUtils.isEmpty(logBaiYeGetList)) {
            List<LogBaiYeGet> list;
            synchronized (logBaiYeGetList) {
                list = new ArrayList<>(logBaiYeGetList);
                logBaiYeGetList.clear();
            }
            LogBussiness.addLogBaiYeGet(list);
        }
    }

    public static void addLogBusyFarmingHarvest(LogBusyFarmingHarvest logBusyFarmingHarvest) {
        synchronized (logBusyFarmingHarvestList) {
            logBusyFarmingHarvestList.add(logBusyFarmingHarvest);
        }
    }

    public static void addLogBusyFarmingLandBuy(LogBusyFarmingLandBuy logBusyFarmingLandBuy) {
        synchronized (logBusyFarmingLandBuyList) {
            logBusyFarmingLandBuyList.add(logBusyFarmingLandBuy);
        }
    }

    public static void addLogBusyFarmingPlant(LogBusyFarmingPlant logBusyFarmingPlant) {
        synchronized (logBusyFarmingPlantList) {
            logBusyFarmingPlantList.add(logBusyFarmingPlant);
        }
    }

    public static void addLogBusyFarmingQuicken(LogBusyFarmingQuicken logBusyFarmingQuicken) {
        synchronized (logBusyFarmingQuickenList) {
            logBusyFarmingQuickenList.add(logBusyFarmingQuicken);
        }
    }

    public static void addLogBusyFarmingRemove(LogBusyFarmingRemove logBusyFarmingRemove) {
        synchronized (logBusyFarmingRemoveList) {
            logBusyFarmingRemoveList.add(logBusyFarmingRemove);
        }
    }

    public static void addLogBusyFarmingSteal(LogBusyFarmingSteal logBusyFarmingSteal) {
        synchronized (logBusyFarmingStealList) {
            logBusyFarmingStealList.add(logBusyFarmingSteal);
        }
    }

    public static void addLogBusyFarmingWatering(LogBusyFarmingWatering logBusyFarmingWatering) {
        synchronized (logBusyFarmingWateringList) {
            logBusyFarmingWateringList.add(logBusyFarmingWatering);
        }
    }

    private static void saveBusyFarming() {
        if (!CollectionUtils.isEmpty(logBusyFarmingHarvestList)) {
            List<LogBusyFarmingHarvest> list;
            synchronized (logBusyFarmingHarvestList) {
                list = new ArrayList<>(logBusyFarmingHarvestList);
                logBusyFarmingHarvestList.clear();
            }
            LogBussiness.addLogBusyFarmingHarvest(list);
        }

        if (!CollectionUtils.isEmpty(logBusyFarmingLandBuyList)) {
            List<LogBusyFarmingLandBuy> list;
            synchronized (logBusyFarmingLandBuyList) {
                list = new ArrayList<>(logBusyFarmingLandBuyList);
                logBusyFarmingLandBuyList.clear();
            }
            LogBussiness.addLogBusyFarmingLandBuy(list);
        }

        if (!CollectionUtils.isEmpty(logBusyFarmingPlantList)) {
            List<LogBusyFarmingPlant> list;
            synchronized (logBusyFarmingPlantList) {
                list = new ArrayList<>(logBusyFarmingPlantList);
                logBusyFarmingPlantList.clear();
            }
            LogBussiness.addLogBusyFarmingPlant(list);
        }

        if (!CollectionUtils.isEmpty(logBusyFarmingQuickenList)) {
            List<LogBusyFarmingQuicken> list;
            synchronized (logBusyFarmingQuickenList) {
                list = new ArrayList<>(logBusyFarmingQuickenList);
                logBusyFarmingQuickenList.clear();
            }
            LogBussiness.addLogBusyFarmingQuicken(list);
        }

        if (!CollectionUtils.isEmpty(logBusyFarmingRemoveList)) {
            List<LogBusyFarmingRemove> list;
            synchronized (logBusyFarmingRemoveList) {
                list = new ArrayList<>(logBusyFarmingRemoveList);
                logBusyFarmingRemoveList.clear();
            }
            LogBussiness.addLogBusyFarmingRemove(list);
        }

        if (!CollectionUtils.isEmpty(logBusyFarmingStealList)) {
            List<LogBusyFarmingSteal> list;
            synchronized (logBusyFarmingStealList) {
                list = new ArrayList<>(logBusyFarmingStealList);
                logBusyFarmingStealList.clear();
            }
            LogBussiness.addLogBusyFarmingSteal(list);
        }

        if (!CollectionUtils.isEmpty(logBusyFarmingWateringList)) {
            List<LogBusyFarmingWatering> list;
            synchronized (logBusyFarmingWateringList) {
                list = new ArrayList<>(logBusyFarmingWateringList);
                logBusyFarmingWateringList.clear();
            }
            LogBussiness.addLogBusyFarmingWatering(list);
        }
    }

    public static void addLogSkinVolumeEmbroideryFix(LogSkinVolumeEmbroideryFix log) {
        synchronized (logSkinVolumeEmbroideryFixList) {
            logSkinVolumeEmbroideryFixList.add(log);
        }
    }

    public static void addLogSkinVolumePiecesGet(LogSkinVolumePiecesGet log) {
        synchronized (logSkinVolumePiecesGetList) {
            logSkinVolumePiecesGetList.add(log);
        }
    }

    public static void saveLogSkinVolume() {
        if (!CollectionUtils.isEmpty(logSkinVolumeEmbroideryFixList)) {
            List<LogSkinVolumeEmbroideryFix> list;
            synchronized (logSkinVolumeEmbroideryFixList) {
                list = new ArrayList<>(logSkinVolumeEmbroideryFixList);
                logSkinVolumeEmbroideryFixList.clear();
            }
            LogBussiness.addLogSkinVolumeEmbroideryFix(list);
        }

        if (!CollectionUtils.isEmpty(logSkinVolumePiecesGetList)) {
            List<LogSkinVolumePiecesGet> list;
            synchronized (logSkinVolumePiecesGetList) {
                list = new ArrayList<>(logSkinVolumePiecesGetList);
                logSkinVolumePiecesGetList.clear();
            }
            LogBussiness.addLogSkinVolumePiecesGet(list);
        }




    }

    public static void addLogThiefReward(LogThiefReward log) {
        synchronized (logThiefRewardList) {
            logThiefRewardList.add(log);
        }
    }

    public static void saveLogThiefReward() {
        if (!CollectionUtils.isEmpty(logThiefRewardList)) {
            List<LogThiefReward> list;
            synchronized (logThiefRewardList) {
                list = new ArrayList<>(logThiefRewardList);
                logThiefRewardList.clear();
            }
            LogBussiness.addLogThiefReward(list);
        }
    }

    private static void saveLogUnionChamberDispatch() {
        if (!CollectionUtils.isEmpty(logUnionChamberDispatchList)) {
            List<LogUnionChamberDispatch> list;
            synchronized (logUnionChamberDispatchList) {
                list = new ArrayList<>(logUnionChamberDispatchList);
                logUnionChamberDispatchList.clear();
            }
            LogBussiness.addLogUnionChamberDispatch(list);
        }
    }


    public static void addLogUnionChamberDispatch(LogUnionChamberDispatch logUnionChamberDispatch) {
        synchronized (logUnionChamberDispatchList) {
            logUnionChamberDispatchList.add(logUnionChamberDispatch);
        }
    }


    public static void addLogManorHarvest(LogManorHarvest log) {
        synchronized (logManorHarvestList) {
            logManorHarvestList.add(log);
        }
    }

    public static void addLogManorSpecialSkillLvUp(LogManorSpecialSkillLvUp log) {
        synchronized (logManorSpecialSkillLvUpList) {
            logManorSpecialSkillLvUpList.add(log);
        }
    }

    public static void addLogManorSkinLvUp(LogManorSkinLvUp log) {
        synchronized (logManorSkinLvUpList) {
            logManorSkinLvUpList.add(log);
        }
    }

    public static void addLogManorGuestUnLock(LogManorGuestUnLock log) {
        synchronized (logManorGuestUnLockList) {
            logManorGuestUnLockList.add(log);
        }
    }

    public static void addLogManorTechnologySkillLvUp(LogManorTechnologySkillLvUp log) {
        synchronized (logManorTechnologySkillLvUpList) {
            logManorTechnologySkillLvUpList.add(log);
        }
    }

    public static void addLogManorProsperousValueGet(LogManorProsperousValueGet log) {
        synchronized (logManorProsperousValueGetList) {
            logManorProsperousValueGetList.add(log);
        }
    }

    public static void addLogManorOutPutLvUp(LogManorOutPutLvUp log) {
        synchronized (logManorOutPutLvUpList) {
            logManorOutPutLvUpList.add(log);
        }
    }

    public static void addLogManorWeather(LogManorWeather log) {
        synchronized (logManorWeatherList) {
            logManorWeatherList.add(log);
        }
    }

    public static void addLogGoodBanquetRecord(LogGoodBanquetRecord log) {
        synchronized (logGoodBanquetRecordList) {
            logGoodBanquetRecordList.add(log);
        }
    }

    private static void saveLogManor() {
        if (!CollectionUtils.isEmpty(logManorHarvestList)) {
            List<LogManorHarvest> list;
            synchronized (logManorHarvestList) {
                list = new ArrayList<>(logManorHarvestList);
                logManorHarvestList.clear();
            }
            LogBussiness.addLogManorHarvest(list);
        }

        if (!CollectionUtils.isEmpty(logManorSpecialSkillLvUpList)) {
            List<LogManorSpecialSkillLvUp> list;
            synchronized (logManorSpecialSkillLvUpList) {
                list = new ArrayList<>(logManorSpecialSkillLvUpList);
                logManorSpecialSkillLvUpList.clear();
            }
            LogBussiness.addLogManorSpecialSkillLvUp(list);
        }

        if (!CollectionUtils.isEmpty(logManorSkinLvUpList)) {
            List<LogManorSkinLvUp> list;
            synchronized (logManorSkinLvUpList) {
                list = new ArrayList<>(logManorSkinLvUpList);
                logManorSkinLvUpList.clear();
            }
            LogBussiness.addLogManorSkinLvUp(list);
        }

        if (!CollectionUtils.isEmpty(logManorGuestUnLockList)) {
            List<LogManorGuestUnLock> list;
            synchronized (logManorGuestUnLockList) {
                list = new ArrayList<>(logManorGuestUnLockList);
                logManorGuestUnLockList.clear();
            }
            LogBussiness.addLogManorGuestUnLock(list);
        }

        if (!CollectionUtils.isEmpty(logManorTechnologySkillLvUpList)) {
            List<LogManorTechnologySkillLvUp> list;
            synchronized (logManorTechnologySkillLvUpList) {
                list = new ArrayList<>(logManorTechnologySkillLvUpList);
                logManorTechnologySkillLvUpList.clear();
            }
            LogBussiness.addLogManorTechnologySkillLvUp(list);
        }

        if (!CollectionUtils.isEmpty(logManorProsperousValueGetList)) {
            List<LogManorProsperousValueGet> list;
            synchronized (logManorProsperousValueGetList) {
                list = new ArrayList<>(logManorProsperousValueGetList);
                logManorProsperousValueGetList.clear();
            }
            LogBussiness.addLogManorProsperousValueGet(list);
        }

        if (!CollectionUtils.isEmpty(logManorOutPutLvUpList)) {
            List<LogManorOutPutLvUp> list;
            synchronized (logManorOutPutLvUpList) {
                list = new ArrayList<>(logManorOutPutLvUpList);
                logManorOutPutLvUpList.clear();
            }
            LogBussiness.addLogManorOutPutLvUp(list);
        }

        if (!CollectionUtils.isEmpty(logManorWeatherList)) {
            List<LogManorWeather> list;
            synchronized (logManorWeatherList) {
                list = new ArrayList<>(logManorWeatherList);
                logManorWeatherList.clear();
            }
            LogBussiness.addLogManorWeather(list);
        }
    }

    public static void addLogXiaYueSearch(List<LogXiaYueSearch> log) {
        synchronized (logXiaYueSearchList) {
            logXiaYueSearchList.addAll(log);
        }
    }

    public static void saveLogXiaYueSearch() {
        if (!CollectionUtils.isEmpty(logXiaYueSearchList)) {
            List<LogXiaYueSearch> list;
            synchronized (logXiaYueSearchList) {
                list = new ArrayList<>(logXiaYueSearchList);
                logXiaYueSearchList.clear();
            }
            LogBussiness.addLogXiaYueSearch(list);
        }
    }

    public static void addLogCelebrationProcess(LogCelebrationProcess log) {
        synchronized (logCelebrationProcessList) {
            logCelebrationProcessList.add(log);
        }
    }

    public static void addLogCelebrationFestiveChange(LogCelebrationFestiveChange log) {
        synchronized (logCelebrationFestiveChangeList) {
            logCelebrationFestiveChangeList.add(log);
        }
    }

    public static void saveLogCelebration(){
        if (!CollectionUtils.isEmpty(logCelebrationProcessList)) {
            List<LogCelebrationProcess> list;
            synchronized (logCelebrationProcessList) {
                list = new ArrayList<>(logCelebrationProcessList);
                logCelebrationProcessList.clear();
            }
            LogBussiness.addLogCelebrationProcess(list);
        }
        if (!CollectionUtils.isEmpty(logCelebrationFestiveChangeList)) {
            List<LogCelebrationFestiveChange> list;
            synchronized (logCelebrationFestiveChangeList) {
                list = new ArrayList<>(logCelebrationFestiveChangeList);
                logCelebrationFestiveChangeList.clear();
            }
            LogBussiness.addLogCelebrationFestiveChange(list);
        }
    }

    public static void addLogLanRuoSiEliminate1(LogLanRuoSiEliminate1 log) {
        synchronized (logLanRuoSiEliminate1List) {
            logLanRuoSiEliminate1List.add(log);
        }
    }

    public static void saveLogLanRuoSiEliminate1() {
        if (!CollectionUtils.isEmpty(logLanRuoSiEliminate1List)) {
            List<LogLanRuoSiEliminate1> list;
            synchronized (logLanRuoSiEliminate1List) {
                list = new ArrayList<>(logLanRuoSiEliminate1List);
                logLanRuoSiEliminate1List.clear();
            }
            LogBussiness.addLogLanRuoSiEliminate1(list);
        }
    }

    public static void addLogLanRuoSiEliminate2(LogLanRuoSiEliminate2 log) {
        synchronized (logLanRuoSiEliminate2List) {
            logLanRuoSiEliminate2List.add(log);
        }
    }

    public static void saveLogLanRuoSiEliminate2() {
        if (!CollectionUtils.isEmpty(logLanRuoSiEliminate2List)) {
            List<LogLanRuoSiEliminate2> list;
            synchronized (logLanRuoSiEliminate2List) {
                list = new ArrayList<>(logLanRuoSiEliminate2List);
                logLanRuoSiEliminate2List.clear();
            }
            LogBussiness.addLogLanRuoSiEliminate2(list);
        }
    }

    public static void addLogLanRuoSiEnergy(LogLanRuoSiEnergy log) {
        synchronized (logLanRuoSiEnergyList) {
            logLanRuoSiEnergyList.add(log);
        }
    }

    public static void saveLogLanRuoSiEnergy() {
        if (!CollectionUtils.isEmpty(logLanRuoSiEnergyList)) {
            List<LogLanRuoSiEnergy> list;
            synchronized (logLanRuoSiEnergyList) {
                list = new ArrayList<>(logLanRuoSiEnergyList);
                logLanRuoSiEnergyList.clear();
            }
            LogBussiness.addLogLanRuoSiEnergy(list);
        }
    }

    public static void addLogTreasureFind(LogTreasureFind log) {
        synchronized (logTreasureFindList) {
            logTreasureFindList.add(log);
        }
    }

    public static void saveLogTreasureFind() {
        if (!CollectionUtils.isEmpty(logTreasureFindList)) {
            List<LogTreasureFind> list;
            synchronized (logTreasureFindList) {
                list = new ArrayList<>(logTreasureFindList);
                logTreasureFindList.clear();
            }
            LogBussiness.addLogTreasureFind(list);
        }
    }
    public static void saveLogGourdChild(){

        if (!CollectionUtils.isEmpty(logGourdChildMopUpList)) {
            List<LogGourdChildMopUp> list;
            synchronized (logGourdChildMopUpList) {
                list = new ArrayList<>(logGourdChildMopUpList);
                logGourdChildMopUpList.clear();
            }
            LogBussiness.addLogGourdChildMopUp(list);
        }

        if (!CollectionUtils.isEmpty(logGourdChildDrawList)) {
            List<LogGourdChildDraw> list;
            synchronized (logGourdChildDrawList) {
                list = new ArrayList<>(logGourdChildDrawList);
                logGourdChildDrawList.clear();
            }
            LogBussiness.addLogGourdChildDraw(list);
        }
    }

    public static void saveLogGourdPlant(){
        if (!CollectionUtils.isEmpty(logGourdPlantWateringList)) {
            List<LogGourdPlantWatering> list;
            synchronized (logGourdPlantWateringList) {
                list = new ArrayList<>(logGourdPlantWateringList);
                logGourdPlantWateringList.clear();
            }
            LogBussiness.addLogGourdPlantWatering(list);
        }
    }

    public static void addLogGourdChildMopUp(LogGourdChildMopUp log) {
        synchronized (logGourdChildMopUpList) {
            logGourdChildMopUpList.add(log);
        }
    }

    public static void addLogGourdChildDraw(LogGourdChildDraw log) {
        synchronized (logGourdChildDrawList) {
            logGourdChildDrawList.add(log);
        }
    }

    public static void addLogGourdPlantWatering(LogGourdPlantWatering log) {
        synchronized (logGourdPlantWateringList) {
            logGourdPlantWateringList.add(log);
        }
    }

    public static void addMonopolyMarketUserPhysicalChangeLogData(MonopolyMarketUserPhysicalChangeLogData item){
        synchronized (logMonopolyMarketUserPhysicalChangeLogDataList){
            logMonopolyMarketUserPhysicalChangeLogDataList.add(item);
        }
    }

    public static void addMonopolyMarketFortressDispatchLogData(MonopolyMarketFortressDispatchLogData item){
        synchronized (logMonopolyMarketFortressDispatchLogDataList){
            logMonopolyMarketFortressDispatchLogDataList.add(item);
        }
    }

    public static void addMonopolyMarketOfficeUserSeatLogData(MonopolyMarketOfficeUserSeatLogData item){
        synchronized (logMonopolyMarketOfficeUserSeatLogDataList){
            logMonopolyMarketOfficeUserSeatLogDataList.add(item);
        }
    }

    private static void saveLogMonopolyMarket(){
        if (!CollectionUtils.isEmpty(logMonopolyMarketUserPhysicalChangeLogDataList)) {
            List<MonopolyMarketUserPhysicalChangeLogData> list;
            synchronized (logMonopolyMarketUserPhysicalChangeLogDataList) {
                list = new ArrayList<>(logMonopolyMarketUserPhysicalChangeLogDataList);
                logMonopolyMarketUserPhysicalChangeLogDataList.clear();
            }
            LogBussiness.addMonopolyMarketUserPhysicalChangeLogData(list);
        }
        if (!CollectionUtils.isEmpty(logMonopolyMarketFortressDispatchLogDataList)) {
            List<MonopolyMarketFortressDispatchLogData> list;
            synchronized (logMonopolyMarketFortressDispatchLogDataList) {
                list = new ArrayList<>(logMonopolyMarketFortressDispatchLogDataList);
                logMonopolyMarketFortressDispatchLogDataList.clear();
            }
            LogBussiness.addMonopolyMarketFortressDispatchLogData(list);
        }
        if (!CollectionUtils.isEmpty(logMonopolyMarketOfficeUserSeatLogDataList)) {
            List<MonopolyMarketOfficeUserSeatLogData> list;
            synchronized (logMonopolyMarketOfficeUserSeatLogDataList) {
                list = new ArrayList<>(logMonopolyMarketOfficeUserSeatLogDataList);
                logMonopolyMarketOfficeUserSeatLogDataList.clear();
            }
            LogBussiness.addMonopolyMarketOfficeUserSeatLogData(list);
        }

    }

    public static void addLogWinterLoveDig(LogWinterLoveDig item){
        synchronized (logWinterLoveDigList){
            logWinterLoveDigList.add(item);
        }
    }

    private static void saveLogWinterLoveDig(){
        if(!CollectionUtils.isEmpty(logWinterLoveDigList)){
            List<LogWinterLoveDig> list;
            synchronized (logWinterLoveDigList){
                list = new ArrayList<>(logWinterLoveDigList);
                logWinterLoveDigList.clear();
            }
            LogBussiness.addLogWinterLoveDig(list);
        }
    }

    public static void addLogWinterLovePickUpItem(LogWinterLovePickUpItem item){
        synchronized (logWinterLovePickUpItemList){
            logWinterLovePickUpItemList.add(item);
        }
    }

    private static void saveLogWinterLovePickUpItem(){
        if (!CollectionUtils.isEmpty(logWinterLovePickUpItemList)){
            List<LogWinterLovePickUpItem> list;
            synchronized (logWinterLovePickUpItemList){
                list = new ArrayList<>(logWinterLovePickUpItemList);
                logWinterLovePickUpItemList.clear();
            }
            LogBussiness.addLogWinterLovePickUpItem(list);
        }
    }

    public static void addWinterLoveConvertReward(LogWinterLoveConvertReward item){
        synchronized (logWinterLoveConvertRewardList){
            logWinterLoveConvertRewardList.add(item);
        }
    }

    private static void saveLogWinterLoveConvertReward(){
        if(!CollectionUtils.isEmpty(logWinterLoveConvertRewardList)){
            List<LogWinterLoveConvertReward> list;
            synchronized (logWinterLoveConvertRewardList){
                list = new ArrayList<>(logWinterLoveConvertRewardList);
                logWinterLoveConvertRewardList.clear();
            }
            LogBussiness.addLogWinterLoveConvertReward(list);
        }
    }
    public static void addLogHellNpc(LogHellNpc log) {
        synchronized (logHellNpcList) {
            logHellNpcList.add(log);
        }
    }

    public static void saveLogHell(){
        if (!CollectionUtils.isEmpty(logHellNpcList)) {
            List<LogHellNpc> list;
            synchronized (logHellNpcList) {
                list = new ArrayList<>(logHellNpcList);
                logHellNpcList.clear();
            }
            LogBussiness.addLogHellNpc(list);
        }
    }

    public static void addLogShuShanBuildUp(LogShuShanBuildUp log) {
        synchronized (logShuShanBuildUpList) {
            logShuShanBuildUpList.add(log);
        }
    }

    public static void addLogShuShanGetDisciple(LogShuShanGetDisciple log) {
        synchronized (logShuShanGetDiscipleList) {
            logShuShanGetDiscipleList.add(log);
        }
    }

    public static void addLogShuShanKickOutDisciple(LogShuShanKickOutDisciple log) {
        synchronized (logShuShanKickOutDiscipleList) {
            logShuShanKickOutDiscipleList.add(log);
        }
    }

    public static void addLogShuShanReceiveLiLianReward(LogShuShanReceiveLiLianReward log) {
        synchronized (logShuShanReceiveLiLianRewardList) {
            logShuShanReceiveLiLianRewardList.add(log);
        }
    }

    public static void addLogShuShanEventRecord(LogShuShanEventRecord log) {
        synchronized (logShuShanEventRecordList) {
            logShuShanEventRecordList.add(log);
        }
    }

    public static void addLogShuShanExerciseRecord(LogShuShanExerciseRecord log) {
        synchronized (logShuShanExerciseRecordList) {
            logShuShanExerciseRecordList.add(log);
        }
    }


    public static void addLogShuiHuYeZiCardBattlerResultRecord(LogShuiHuYeZiCardBattlerResultRecord log) {
        synchronized (logShuiHuYeZiCardBattlerResultRecordList) {
            logShuiHuYeZiCardBattlerResultRecordList.add(log);
        }
    }

    public static void addLogShuiHuYeZiCardGetCard(LogShuiHuYeZiCardGetCard log) {
        synchronized (logShuiHuYeZiCardGetCardList) {
            logShuiHuYeZiCardGetCardList.add(log);
        }
    }

    public static void addLogShuiHuYeZiCardPVEBattlerRoundRecord(LogShuiHuYeZiCardPVEBattlerRoundRecord log) {
        synchronized (logShuiHuYeZiCardPVEBattlerRoundRecordList) {
            logShuiHuYeZiCardPVEBattlerRoundRecordList.add(log);
        }
    }

    private static void saveLogGoodBanquet(){
        if (!CollectionUtils.isEmpty(logGoodBanquetRecordList)) {
            List<LogGoodBanquetRecord> list;
            synchronized (logGoodBanquetRecordList) {
                list = new ArrayList<>(logGoodBanquetRecordList);
                logGoodBanquetRecordList.clear();
            }
            LogBussiness.addLogGoodBanquetRecord(list);
        }
    }

    private static void saveLogShuiHuYeZiCard(){
        if (!CollectionUtils.isEmpty(logShuiHuYeZiCardBattlerResultRecordList)) {
            List<LogShuiHuYeZiCardBattlerResultRecord> list;
            synchronized (logShuiHuYeZiCardBattlerResultRecordList) {
                list = new ArrayList<>(logShuiHuYeZiCardBattlerResultRecordList);
                logShuiHuYeZiCardBattlerResultRecordList.clear();
            }
            LogBussiness.addLogShuiHuYeZiCardBattlerResultRecordList(list);
        }
        if (!CollectionUtils.isEmpty(logShuiHuYeZiCardGetCardList)) {
            List<LogShuiHuYeZiCardGetCard> list;
            synchronized (logShuiHuYeZiCardGetCardList) {
                list = new ArrayList<>(logShuiHuYeZiCardGetCardList);
                logShuiHuYeZiCardGetCardList.clear();
            }
            LogBussiness.addLogShuiHuYeZiCardGetCardList(list);
        }
        if (!CollectionUtils.isEmpty(logShuiHuYeZiCardPVEBattlerRoundRecordList)) {
            List<LogShuiHuYeZiCardPVEBattlerRoundRecord> list;
            synchronized (logShuiHuYeZiCardPVEBattlerRoundRecordList) {
                list = new ArrayList<>(logShuiHuYeZiCardPVEBattlerRoundRecordList);
                logShuiHuYeZiCardPVEBattlerRoundRecordList.clear();
            }
            LogBussiness.addLogShuiHuYeZiCardPVEBattlerRoundRecordList(list);
        }

    }


    public static void addLogToyHouseOrder(LogToyHouseOrder log) {
        synchronized (logToyHouseOrderList) {
            logToyHouseOrderList.add(log);
        }
    }

    private static void saveLogToyHouseOrder() {
        if (!CollectionUtils.isEmpty(logToyHouseOrderList)) {
            List<LogToyHouseOrder> list;
            synchronized (logToyHouseOrderList) {
                list = new ArrayList<>(logToyHouseOrderList);
                logToyHouseOrderList.clear();
            }
            LogBussiness.addLogToyHouseOrder(list);
        }
    }

    public static void addLogToyHouseEliminate(LogToyHouseEliminate log) {
        synchronized (logToyHouseEliminateList) {
            logToyHouseEliminateList.add(log);
        }
    }

    private static void saveLogToyHouseEliminate() {
        if (!CollectionUtils.isEmpty(logToyHouseEliminateList)) {
            List<LogToyHouseEliminate> list;
            synchronized (logToyHouseEliminateList) {
                list = new ArrayList<>(logToyHouseEliminateList);
                logToyHouseEliminateList.clear();
            }
            LogBussiness.addLogToyHouseEliminate(list);
        }
    }

    public static void addLogToyHouseCandy(LogToyHouseCandy log) {
        synchronized (logToyHouseCandyList) {
            logToyHouseCandyList.add(log);
        }
    }

    private static void saveLogToyHouseCandy() {
        if (!CollectionUtils.isEmpty(logToyHouseCandyList)) {
            List<LogToyHouseCandy> list;
            synchronized (logToyHouseCandyList) {
                list = new ArrayList<>(logToyHouseCandyList);
                logToyHouseCandyList.clear();
            }
            LogBussiness.addLogToyHouseCandy(list);
        }
    }

    private static void saveLogShuShan() {
        if (!CollectionUtils.isEmpty(logShuShanBuildUpList)) {
            List<LogShuShanBuildUp> list;
            synchronized (logShuShanBuildUpList) {
                list = new ArrayList<>(logShuShanBuildUpList);
                logShuShanBuildUpList.clear();
            }
            LogBussiness.addLogShuShanBuildUpList(list);
        }

        if (!CollectionUtils.isEmpty(logShuShanGetDiscipleList)) {
            List<LogShuShanGetDisciple> list;
            synchronized (logShuShanGetDiscipleList) {
                list = new ArrayList<>(logShuShanGetDiscipleList);
                logShuShanGetDiscipleList.clear();
            }
            LogBussiness.addLogShuShanGetDiscipleList(list);
        }

        if (!CollectionUtils.isEmpty(logShuShanKickOutDiscipleList)) {
            List<LogShuShanKickOutDisciple> list;
            synchronized (logShuShanKickOutDiscipleList) {
                list = new ArrayList<>(logShuShanKickOutDiscipleList);
                logShuShanKickOutDiscipleList.clear();
            }
            LogBussiness.addLogShuShanKickOutDiscipleList(list);
        }

        if (!CollectionUtils.isEmpty(logShuShanReceiveLiLianRewardList)) {
            List<LogShuShanReceiveLiLianReward> list;
            synchronized (logShuShanReceiveLiLianRewardList) {
                list = new ArrayList<>(logShuShanReceiveLiLianRewardList);
                logShuShanReceiveLiLianRewardList.clear();
            }
            LogBussiness.addLogShuShanReceiveLiLianRewardList(list);
        }

        if (!CollectionUtils.isEmpty(logShuShanEventRecordList)) {
            List<LogShuShanEventRecord> list;
            synchronized (logShuShanEventRecordList) {
                list = new ArrayList<>(logShuShanEventRecordList);
                logShuShanEventRecordList.clear();
            }
            LogBussiness.addLogShuShanEventRecordList(list);
        }
        if (!CollectionUtils.isEmpty(logShuShanExerciseRecordList)) {
            List<LogShuShanExerciseRecord> list;
            synchronized (logShuShanExerciseRecordList) {
                list = new ArrayList<>(logShuShanExerciseRecordList);
                logShuShanExerciseRecordList.clear();
            }
            LogBussiness.addLogShuShanExerciseRecordList(list);
        }

    }

    public static void addLogMemoryPiecesLightUp(LogMemoryPiecesLightUp log) {
        synchronized (logMemoryPiecesLightUpList) {
            logMemoryPiecesLightUpList.add(log);
        }
    }

    private static void saveLogMemoryPiecesLightUp() {
        if (!CollectionUtils.isEmpty(logMemoryPiecesLightUpList)) {
            List<LogMemoryPiecesLightUp> list;
            synchronized (logMemoryPiecesLightUpList) {
                list = new ArrayList<>(logMemoryPiecesLightUpList);
                logMemoryPiecesLightUpList.clear();
            }
            LogBussiness.addLogMemoryPiecesLightUpList(list);
        }
    }

    public static void addLogTwinsKungFuDraw(LogTwinsDrawKungFu log) {
        synchronized (logTwinsDrawKungFuList) {
            logTwinsDrawKungFuList.add(log);
        }
    }

    public static void addLogTwinsKungFuUpgrade(LogTwinsKungFuUpgrade log) {
        synchronized (logTwinsKungFuUpgradeList) {
            logTwinsKungFuUpgradeList.add(log);
        }
    }

    public static void addLogTwinsKungFuCombUplock(LogTwinsKungFuCombUnlock log) {
        synchronized (logTwinsKungFuCombUnlockList) {
            logTwinsKungFuCombUnlockList.add(log);
        }
    }

    public static void addLogTwinsPveBattle(LogTwinsPveBattle log) {
        synchronized (logTwinsPveBattleList) {
            logTwinsPveBattleList.add(log);
        }
    }


    public static void addLogWorldCupSkill(LogWorldCupSkill log) {
        synchronized (logWorldCupSkillList) {
            logWorldCupSkillList.add(log);
        }
    }

    public static void addLogWorldCupKick(LogWorldCupKick log) {
        synchronized (logWorldCupKickList) {
            logWorldCupKickList.add(log);
        }
    }

    public static void addLogWorldCupRecruit(LogWorldCupRecruit log) {
        synchronized (logWorldCupRecruitList) {
            logWorldCupRecruitList.add(log);
        }
    }

    private static void saveLogCup(){
        if (!CollectionUtils.isEmpty(logWorldCupSkillList)) {
            List<LogWorldCupSkill> list;
            synchronized (logWorldCupSkillList) {
                list = new ArrayList<>(logWorldCupSkillList);
                logWorldCupSkillList.clear();
            }
            LogBussiness.addLogWorldCupSkillList(list);
        }

        if (!CollectionUtils.isEmpty(logWorldCupKickList)) {
            List<LogWorldCupKick> list;
            synchronized (logWorldCupKickList) {
                list = new ArrayList<>(logWorldCupKickList);
                logWorldCupKickList.clear();
            }
            LogBussiness.addLogWorldCupKickList(list);
        }

        if (!CollectionUtils.isEmpty(logWorldCupRecruitList)) {
            List<LogWorldCupRecruit> list;
            synchronized (logWorldCupRecruitList) {
                list = new ArrayList<>(logWorldCupRecruitList);
                logWorldCupRecruitList.clear();
            }
            LogBussiness.addLogWorldCupRecruitList(list);
        }
    }


    private static void saveLogTwins() {
        if (!CollectionUtils.isEmpty(logTwinsDrawKungFuList)) {
            List<LogTwinsDrawKungFu> list;
            synchronized (logTwinsDrawKungFuList) {
                list = new ArrayList<>(logTwinsDrawKungFuList);
                logTwinsDrawKungFuList.clear();
            }
            LogBussiness.addLogTwinsKungFuDrawList(list);
        }

        if (!CollectionUtils.isEmpty(logTwinsKungFuUpgradeList)) {
            List<LogTwinsKungFuUpgrade> list;
            synchronized (logTwinsKungFuUpgradeList) {
                list = new ArrayList<>(logTwinsKungFuUpgradeList);
                logTwinsKungFuUpgradeList.clear();
            }
            LogBussiness.addLogTwinsKungFuUpgradeList(list);
        }

        if (!CollectionUtils.isEmpty(logTwinsKungFuCombUnlockList)) {
            List<LogTwinsKungFuCombUnlock> list;
            synchronized (logTwinsKungFuCombUnlockList) {
                list = new ArrayList<>(logTwinsKungFuCombUnlockList);
                logTwinsKungFuCombUnlockList.clear();
            }
            LogBussiness.addLogTwinsKungFuCombUplockList(list);
        }

        if (!CollectionUtils.isEmpty(logTwinsPveBattleList)) {
            List<LogTwinsPveBattle> list;
            synchronized (logTwinsPveBattleList) {
                list = new ArrayList<>(logTwinsPveBattleList);
                logTwinsPveBattleList.clear();
            }
            LogBussiness.addLogTwinsPveBattleList(list);
        }

    }

    /**
     * 节日自选礼包日志
     * @param log
     */
    public static void addLogActivityFestivalGiftBuy(LogActivityFestivalGiftBuy log) {
        synchronized (logActivityFestivalGiftBuyList) {
            logActivityFestivalGiftBuyList.add(log);
        }
    }

    /**
     * 节日自选礼包日志
     */
    public static void saveLogActivityFestivalGiftBuy() {
        if (!CollectionUtils.isEmpty(logActivityFestivalGiftBuyList)) {
            List<LogActivityFestivalGiftBuy> list;
            synchronized (logActivityFestivalGiftBuyList) {
                list = new ArrayList<>(logActivityFestivalGiftBuyList);
                logActivityFestivalGiftBuyList.clear();
            }
            LogBussiness.addLogActivityFestivalGiftBuy(list);
        }
    }
}
